<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">

<html lang="en">

<head>
  <meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
  <title>LCOV - coverage_clean.info - usr/include/x86_64-linux-gnu/c++/13/bits/c++config.h</title>
  <link rel="stylesheet" type="text/css" href="../../../../../../gcov.css">
</head>

<body>

          <table width="100%" border=0 cellspacing=0 cellpadding=0>
            <tr><td class="title">LCOV - code coverage report</td></tr>
            <tr><td class="ruler"><img src="../../../../../../glass.png" width=3 height=3 alt=""></td></tr>

            <tr>
              <td width="100%">
                <table cellpadding=1 border=0 width="100%">
          <tr>
            <td width="10%" class="headerItem">Current view:</td>
            <td width="10%" class="headerValue"><a href="../../../../../../index.html">top level</a> - <a href="index.html">/usr/include/x86_64-linux-gnu/c++/13/bits</a> - c++config.h<span style="font-size: 80%;"> (source / <a href="c++config.h.func-c.html">functions</a>)</span></td>
            <td width="5%"></td>
            <td width="5%"></td>
            <td width="5%" class="headerCovTableHead">Coverage</td>
            <td width="5%" class="headerCovTableHead" title="Covered + Uncovered code">Total</td>
            <td width="5%" class="headerCovTableHead" title="Exercised code only">Hit</td>
          </tr>
          <tr>
            <td class="headerItem">Test:</td>
            <td class="headerValue">coverage_clean.info</td>
            <td></td>
            <td class="headerItem">Lines:</td>
            <td class="headerCovTableEntryHi">100.0&nbsp;%</td>
            <td class="headerCovTableEntry">2</td>
            <td class="headerCovTableEntry">2</td>
          </tr>
          <tr>
            <td class="headerItem">Test Date:</td>
            <td class="headerValue">2025-11-25 04:45:29</td>
            <td></td>
            <td class="headerItem">Functions:</td>
            <td class="headerCovTableEntryHi">100.0&nbsp;%</td>
            <td class="headerCovTableEntry">1</td>
            <td class="headerCovTableEntry">1</td>
          </tr>
                  <tr><td><img src="../../../../../../glass.png" width=3 height=3 alt=""></td></tr>
                </table>
              </td>
            </tr>

            <tr><td class="ruler"><img src="../../../../../../glass.png" width=3 height=3 alt=""></td></tr>
          </table>

          <table cellpadding=0 cellspacing=0 border=0>
            <tr>
              <td><br></td>
            </tr>
            <tr>
              <td>
<pre class="sourceHeading">            Line data    Source code</pre>
<pre class="source">
<span id="L1"><span class="lineNum">       1</span>              : // Predefined symbols and macros -*- C++ -*-</span>
<span id="L2"><span class="lineNum">       2</span>              : </span>
<span id="L3"><span class="lineNum">       3</span>              : // Copyright (C) 1997-2023 Free Software Foundation, Inc.</span>
<span id="L4"><span class="lineNum">       4</span>              : //</span>
<span id="L5"><span class="lineNum">       5</span>              : // This file is part of the GNU ISO C++ Library.  This library is free</span>
<span id="L6"><span class="lineNum">       6</span>              : // software; you can redistribute it and/or modify it under the</span>
<span id="L7"><span class="lineNum">       7</span>              : // terms of the GNU General Public License as published by the</span>
<span id="L8"><span class="lineNum">       8</span>              : // Free Software Foundation; either version 3, or (at your option)</span>
<span id="L9"><span class="lineNum">       9</span>              : // any later version.</span>
<span id="L10"><span class="lineNum">      10</span>              : </span>
<span id="L11"><span class="lineNum">      11</span>              : // This library is distributed in the hope that it will be useful,</span>
<span id="L12"><span class="lineNum">      12</span>              : // but WITHOUT ANY WARRANTY; without even the implied warranty of</span>
<span id="L13"><span class="lineNum">      13</span>              : // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the</span>
<span id="L14"><span class="lineNum">      14</span>              : // GNU General Public License for more details.</span>
<span id="L15"><span class="lineNum">      15</span>              : </span>
<span id="L16"><span class="lineNum">      16</span>              : // Under Section 7 of GPL version 3, you are granted additional</span>
<span id="L17"><span class="lineNum">      17</span>              : // permissions described in the GCC Runtime Library Exception, version</span>
<span id="L18"><span class="lineNum">      18</span>              : // 3.1, as published by the Free Software Foundation.</span>
<span id="L19"><span class="lineNum">      19</span>              : </span>
<span id="L20"><span class="lineNum">      20</span>              : // You should have received a copy of the GNU General Public License and</span>
<span id="L21"><span class="lineNum">      21</span>              : // a copy of the GCC Runtime Library Exception along with this program;</span>
<span id="L22"><span class="lineNum">      22</span>              : // see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see</span>
<span id="L23"><span class="lineNum">      23</span>              : // &lt;http://www.gnu.org/licenses/&gt;.</span>
<span id="L24"><span class="lineNum">      24</span>              : </span>
<span id="L25"><span class="lineNum">      25</span>              : /** @file bits/c++config.h</span>
<span id="L26"><span class="lineNum">      26</span>              :  *  This is an internal header file, included by other library headers.</span>
<span id="L27"><span class="lineNum">      27</span>              :  *  Do not attempt to use it directly. @headername{version}</span>
<span id="L28"><span class="lineNum">      28</span>              :  */</span>
<span id="L29"><span class="lineNum">      29</span>              : </span>
<span id="L30"><span class="lineNum">      30</span>              : #ifndef _GLIBCXX_CXX_CONFIG_H</span>
<span id="L31"><span class="lineNum">      31</span>              : #define _GLIBCXX_CXX_CONFIG_H 1</span>
<span id="L32"><span class="lineNum">      32</span>              : </span>
<span id="L33"><span class="lineNum">      33</span>              : // The major release number for the GCC release the C++ library belongs to.</span>
<span id="L34"><span class="lineNum">      34</span>              : #define _GLIBCXX_RELEASE 13</span>
<span id="L35"><span class="lineNum">      35</span>              : </span>
<span id="L36"><span class="lineNum">      36</span>              : // The datestamp of the C++ library in compressed ISO date format.</span>
<span id="L37"><span class="lineNum">      37</span>              : #define __GLIBCXX__ 20240904</span>
<span id="L38"><span class="lineNum">      38</span>              : </span>
<span id="L39"><span class="lineNum">      39</span>              : // Macros for various attributes.</span>
<span id="L40"><span class="lineNum">      40</span>              : //   _GLIBCXX_PURE</span>
<span id="L41"><span class="lineNum">      41</span>              : //   _GLIBCXX_CONST</span>
<span id="L42"><span class="lineNum">      42</span>              : //   _GLIBCXX_NORETURN</span>
<span id="L43"><span class="lineNum">      43</span>              : //   _GLIBCXX_NOTHROW</span>
<span id="L44"><span class="lineNum">      44</span>              : //   _GLIBCXX_VISIBILITY</span>
<span id="L45"><span class="lineNum">      45</span>              : #ifndef _GLIBCXX_PURE</span>
<span id="L46"><span class="lineNum">      46</span>              : # define _GLIBCXX_PURE __attribute__ ((__pure__))</span>
<span id="L47"><span class="lineNum">      47</span>              : #endif</span>
<span id="L48"><span class="lineNum">      48</span>              : </span>
<span id="L49"><span class="lineNum">      49</span>              : #ifndef _GLIBCXX_CONST</span>
<span id="L50"><span class="lineNum">      50</span>              : # define _GLIBCXX_CONST __attribute__ ((__const__))</span>
<span id="L51"><span class="lineNum">      51</span>              : #endif</span>
<span id="L52"><span class="lineNum">      52</span>              : </span>
<span id="L53"><span class="lineNum">      53</span>              : #ifndef _GLIBCXX_NORETURN</span>
<span id="L54"><span class="lineNum">      54</span>              : # define _GLIBCXX_NORETURN __attribute__ ((__noreturn__))</span>
<span id="L55"><span class="lineNum">      55</span>              : #endif</span>
<span id="L56"><span class="lineNum">      56</span>              : </span>
<span id="L57"><span class="lineNum">      57</span>              : // See below for C++</span>
<span id="L58"><span class="lineNum">      58</span>              : #ifndef _GLIBCXX_NOTHROW</span>
<span id="L59"><span class="lineNum">      59</span>              : # ifndef __cplusplus</span>
<span id="L60"><span class="lineNum">      60</span>              : #  define _GLIBCXX_NOTHROW __attribute__((__nothrow__))</span>
<span id="L61"><span class="lineNum">      61</span>              : # endif</span>
<span id="L62"><span class="lineNum">      62</span>              : #endif</span>
<span id="L63"><span class="lineNum">      63</span>              : </span>
<span id="L64"><span class="lineNum">      64</span>              : // Macros for visibility attributes.</span>
<span id="L65"><span class="lineNum">      65</span>              : //   _GLIBCXX_HAVE_ATTRIBUTE_VISIBILITY</span>
<span id="L66"><span class="lineNum">      66</span>              : //   _GLIBCXX_VISIBILITY</span>
<span id="L67"><span class="lineNum">      67</span>              : # define _GLIBCXX_HAVE_ATTRIBUTE_VISIBILITY 1</span>
<span id="L68"><span class="lineNum">      68</span>              : </span>
<span id="L69"><span class="lineNum">      69</span>              : #if _GLIBCXX_HAVE_ATTRIBUTE_VISIBILITY</span>
<span id="L70"><span class="lineNum">      70</span>              : # define _GLIBCXX_VISIBILITY(V) __attribute__ ((__visibility__ (#V)))</span>
<span id="L71"><span class="lineNum">      71</span>              : #else</span>
<span id="L72"><span class="lineNum">      72</span>              : // If this is not supplied by the OS-specific or CPU-specific</span>
<span id="L73"><span class="lineNum">      73</span>              : // headers included below, it will be defined to an empty default.</span>
<span id="L74"><span class="lineNum">      74</span>              : # define _GLIBCXX_VISIBILITY(V) _GLIBCXX_PSEUDO_VISIBILITY(V)</span>
<span id="L75"><span class="lineNum">      75</span>              : #endif</span>
<span id="L76"><span class="lineNum">      76</span>              : </span>
<span id="L77"><span class="lineNum">      77</span>              : // Macros for deprecated attributes.</span>
<span id="L78"><span class="lineNum">      78</span>              : //   _GLIBCXX_USE_DEPRECATED</span>
<span id="L79"><span class="lineNum">      79</span>              : //   _GLIBCXX_DEPRECATED</span>
<span id="L80"><span class="lineNum">      80</span>              : //   _GLIBCXX_DEPRECATED_SUGGEST( string-literal )</span>
<span id="L81"><span class="lineNum">      81</span>              : //   _GLIBCXX11_DEPRECATED</span>
<span id="L82"><span class="lineNum">      82</span>              : //   _GLIBCXX11_DEPRECATED_SUGGEST( string-literal )</span>
<span id="L83"><span class="lineNum">      83</span>              : //   _GLIBCXX14_DEPRECATED</span>
<span id="L84"><span class="lineNum">      84</span>              : //   _GLIBCXX14_DEPRECATED_SUGGEST( string-literal )</span>
<span id="L85"><span class="lineNum">      85</span>              : //   _GLIBCXX17_DEPRECATED</span>
<span id="L86"><span class="lineNum">      86</span>              : //   _GLIBCXX17_DEPRECATED_SUGGEST( string-literal )</span>
<span id="L87"><span class="lineNum">      87</span>              : //   _GLIBCXX20_DEPRECATED</span>
<span id="L88"><span class="lineNum">      88</span>              : //   _GLIBCXX20_DEPRECATED_SUGGEST( string-literal )</span>
<span id="L89"><span class="lineNum">      89</span>              : //   _GLIBCXX23_DEPRECATED</span>
<span id="L90"><span class="lineNum">      90</span>              : //   _GLIBCXX23_DEPRECATED_SUGGEST( string-literal )</span>
<span id="L91"><span class="lineNum">      91</span>              : #ifndef _GLIBCXX_USE_DEPRECATED</span>
<span id="L92"><span class="lineNum">      92</span>              : # define _GLIBCXX_USE_DEPRECATED 1</span>
<span id="L93"><span class="lineNum">      93</span>              : #endif</span>
<span id="L94"><span class="lineNum">      94</span>              : </span>
<span id="L95"><span class="lineNum">      95</span>              : #if defined(__DEPRECATED)</span>
<span id="L96"><span class="lineNum">      96</span>              : # define _GLIBCXX_DEPRECATED __attribute__ ((__deprecated__))</span>
<span id="L97"><span class="lineNum">      97</span>              : # define _GLIBCXX_DEPRECATED_SUGGEST(ALT) \</span>
<span id="L98"><span class="lineNum">      98</span>              :   __attribute__ ((__deprecated__ (&quot;use '&quot; ALT &quot;' instead&quot;)))</span>
<span id="L99"><span class="lineNum">      99</span>              : #else</span>
<span id="L100"><span class="lineNum">     100</span>              : # define _GLIBCXX_DEPRECATED</span>
<span id="L101"><span class="lineNum">     101</span>              : # define _GLIBCXX_DEPRECATED_SUGGEST(ALT)</span>
<span id="L102"><span class="lineNum">     102</span>              : #endif</span>
<span id="L103"><span class="lineNum">     103</span>              : </span>
<span id="L104"><span class="lineNum">     104</span>              : #if defined(__DEPRECATED) &amp;&amp; (__cplusplus &gt;= 201103L)</span>
<span id="L105"><span class="lineNum">     105</span>              : # define _GLIBCXX11_DEPRECATED _GLIBCXX_DEPRECATED</span>
<span id="L106"><span class="lineNum">     106</span>              : # define _GLIBCXX11_DEPRECATED_SUGGEST(ALT) _GLIBCXX_DEPRECATED_SUGGEST(ALT)</span>
<span id="L107"><span class="lineNum">     107</span>              : #else</span>
<span id="L108"><span class="lineNum">     108</span>              : # define _GLIBCXX11_DEPRECATED</span>
<span id="L109"><span class="lineNum">     109</span>              : # define _GLIBCXX11_DEPRECATED_SUGGEST(ALT)</span>
<span id="L110"><span class="lineNum">     110</span>              : #endif</span>
<span id="L111"><span class="lineNum">     111</span>              : </span>
<span id="L112"><span class="lineNum">     112</span>              : #if defined(__DEPRECATED) &amp;&amp; (__cplusplus &gt;= 201402L)</span>
<span id="L113"><span class="lineNum">     113</span>              : # define _GLIBCXX14_DEPRECATED _GLIBCXX_DEPRECATED</span>
<span id="L114"><span class="lineNum">     114</span>              : # define _GLIBCXX14_DEPRECATED_SUGGEST(ALT) _GLIBCXX_DEPRECATED_SUGGEST(ALT)</span>
<span id="L115"><span class="lineNum">     115</span>              : #else</span>
<span id="L116"><span class="lineNum">     116</span>              : # define _GLIBCXX14_DEPRECATED</span>
<span id="L117"><span class="lineNum">     117</span>              : # define _GLIBCXX14_DEPRECATED_SUGGEST(ALT)</span>
<span id="L118"><span class="lineNum">     118</span>              : #endif</span>
<span id="L119"><span class="lineNum">     119</span>              : </span>
<span id="L120"><span class="lineNum">     120</span>              : #if defined(__DEPRECATED) &amp;&amp; (__cplusplus &gt;= 201703L)</span>
<span id="L121"><span class="lineNum">     121</span>              : # define _GLIBCXX17_DEPRECATED [[__deprecated__]]</span>
<span id="L122"><span class="lineNum">     122</span>              : # define _GLIBCXX17_DEPRECATED_SUGGEST(ALT) _GLIBCXX_DEPRECATED_SUGGEST(ALT)</span>
<span id="L123"><span class="lineNum">     123</span>              : #else</span>
<span id="L124"><span class="lineNum">     124</span>              : # define _GLIBCXX17_DEPRECATED</span>
<span id="L125"><span class="lineNum">     125</span>              : # define _GLIBCXX17_DEPRECATED_SUGGEST(ALT)</span>
<span id="L126"><span class="lineNum">     126</span>              : #endif</span>
<span id="L127"><span class="lineNum">     127</span>              : </span>
<span id="L128"><span class="lineNum">     128</span>              : #if defined(__DEPRECATED) &amp;&amp; (__cplusplus &gt;= 202002L)</span>
<span id="L129"><span class="lineNum">     129</span>              : # define _GLIBCXX20_DEPRECATED [[__deprecated__]]</span>
<span id="L130"><span class="lineNum">     130</span>              : # define _GLIBCXX20_DEPRECATED_SUGGEST(ALT) _GLIBCXX_DEPRECATED_SUGGEST(ALT)</span>
<span id="L131"><span class="lineNum">     131</span>              : #else</span>
<span id="L132"><span class="lineNum">     132</span>              : # define _GLIBCXX20_DEPRECATED</span>
<span id="L133"><span class="lineNum">     133</span>              : # define _GLIBCXX20_DEPRECATED_SUGGEST(ALT)</span>
<span id="L134"><span class="lineNum">     134</span>              : #endif</span>
<span id="L135"><span class="lineNum">     135</span>              : </span>
<span id="L136"><span class="lineNum">     136</span>              : #if defined(__DEPRECATED) &amp;&amp; (__cplusplus &gt;= 202100L)</span>
<span id="L137"><span class="lineNum">     137</span>              : # define _GLIBCXX23_DEPRECATED [[__deprecated__]]</span>
<span id="L138"><span class="lineNum">     138</span>              : # define _GLIBCXX23_DEPRECATED_SUGGEST(ALT) _GLIBCXX_DEPRECATED_SUGGEST(ALT)</span>
<span id="L139"><span class="lineNum">     139</span>              : #else</span>
<span id="L140"><span class="lineNum">     140</span>              : # define _GLIBCXX23_DEPRECATED</span>
<span id="L141"><span class="lineNum">     141</span>              : # define _GLIBCXX23_DEPRECATED_SUGGEST(ALT)</span>
<span id="L142"><span class="lineNum">     142</span>              : #endif</span>
<span id="L143"><span class="lineNum">     143</span>              : </span>
<span id="L144"><span class="lineNum">     144</span>              : // Macros for ABI tag attributes.</span>
<span id="L145"><span class="lineNum">     145</span>              : #ifndef _GLIBCXX_ABI_TAG_CXX11</span>
<span id="L146"><span class="lineNum">     146</span>              : # define _GLIBCXX_ABI_TAG_CXX11 __attribute ((__abi_tag__ (&quot;cxx11&quot;)))</span>
<span id="L147"><span class="lineNum">     147</span>              : #endif</span>
<span id="L148"><span class="lineNum">     148</span>              : </span>
<span id="L149"><span class="lineNum">     149</span>              : // Macro to warn about unused results.</span>
<span id="L150"><span class="lineNum">     150</span>              : #if __cplusplus &gt;= 201703L</span>
<span id="L151"><span class="lineNum">     151</span>              : # define _GLIBCXX_NODISCARD [[__nodiscard__]]</span>
<span id="L152"><span class="lineNum">     152</span>              : #else</span>
<span id="L153"><span class="lineNum">     153</span>              : # define _GLIBCXX_NODISCARD</span>
<span id="L154"><span class="lineNum">     154</span>              : #endif</span>
<span id="L155"><span class="lineNum">     155</span>              : </span>
<span id="L156"><span class="lineNum">     156</span>              : </span>
<span id="L157"><span class="lineNum">     157</span>              : </span>
<span id="L158"><span class="lineNum">     158</span>              : #if __cplusplus</span>
<span id="L159"><span class="lineNum">     159</span>              : </span>
<span id="L160"><span class="lineNum">     160</span>              : // Macro for constexpr, to support in mixed 03/0x mode.</span>
<span id="L161"><span class="lineNum">     161</span>              : #ifndef _GLIBCXX_CONSTEXPR</span>
<span id="L162"><span class="lineNum">     162</span>              : # if __cplusplus &gt;= 201103L</span>
<span id="L163"><span class="lineNum">     163</span>              : #  define _GLIBCXX_CONSTEXPR constexpr</span>
<span id="L164"><span class="lineNum">     164</span>              : #  define _GLIBCXX_USE_CONSTEXPR constexpr</span>
<span id="L165"><span class="lineNum">     165</span>              : # else</span>
<span id="L166"><span class="lineNum">     166</span>              : #  define _GLIBCXX_CONSTEXPR</span>
<span id="L167"><span class="lineNum">     167</span>              : #  define _GLIBCXX_USE_CONSTEXPR const</span>
<span id="L168"><span class="lineNum">     168</span>              : # endif</span>
<span id="L169"><span class="lineNum">     169</span>              : #endif</span>
<span id="L170"><span class="lineNum">     170</span>              : </span>
<span id="L171"><span class="lineNum">     171</span>              : #ifndef _GLIBCXX14_CONSTEXPR</span>
<span id="L172"><span class="lineNum">     172</span>              : # if __cplusplus &gt;= 201402L</span>
<span id="L173"><span class="lineNum">     173</span>              : #  define _GLIBCXX14_CONSTEXPR constexpr</span>
<span id="L174"><span class="lineNum">     174</span>              : # else</span>
<span id="L175"><span class="lineNum">     175</span>              : #  define _GLIBCXX14_CONSTEXPR</span>
<span id="L176"><span class="lineNum">     176</span>              : # endif</span>
<span id="L177"><span class="lineNum">     177</span>              : #endif</span>
<span id="L178"><span class="lineNum">     178</span>              : </span>
<span id="L179"><span class="lineNum">     179</span>              : #ifndef _GLIBCXX17_CONSTEXPR</span>
<span id="L180"><span class="lineNum">     180</span>              : # if __cplusplus &gt;= 201703L</span>
<span id="L181"><span class="lineNum">     181</span>              : #  define _GLIBCXX17_CONSTEXPR constexpr</span>
<span id="L182"><span class="lineNum">     182</span>              : # else</span>
<span id="L183"><span class="lineNum">     183</span>              : #  define _GLIBCXX17_CONSTEXPR</span>
<span id="L184"><span class="lineNum">     184</span>              : # endif</span>
<span id="L185"><span class="lineNum">     185</span>              : #endif</span>
<span id="L186"><span class="lineNum">     186</span>              : </span>
<span id="L187"><span class="lineNum">     187</span>              : #ifndef _GLIBCXX20_CONSTEXPR</span>
<span id="L188"><span class="lineNum">     188</span>              : # if __cplusplus &gt;= 202002L</span>
<span id="L189"><span class="lineNum">     189</span>              : #  define _GLIBCXX20_CONSTEXPR constexpr</span>
<span id="L190"><span class="lineNum">     190</span>              : # else</span>
<span id="L191"><span class="lineNum">     191</span>              : #  define _GLIBCXX20_CONSTEXPR</span>
<span id="L192"><span class="lineNum">     192</span>              : # endif</span>
<span id="L193"><span class="lineNum">     193</span>              : #endif</span>
<span id="L194"><span class="lineNum">     194</span>              : </span>
<span id="L195"><span class="lineNum">     195</span>              : #ifndef _GLIBCXX23_CONSTEXPR</span>
<span id="L196"><span class="lineNum">     196</span>              : # if __cplusplus &gt;= 202100L</span>
<span id="L197"><span class="lineNum">     197</span>              : #  define _GLIBCXX23_CONSTEXPR constexpr</span>
<span id="L198"><span class="lineNum">     198</span>              : # else</span>
<span id="L199"><span class="lineNum">     199</span>              : #  define _GLIBCXX23_CONSTEXPR</span>
<span id="L200"><span class="lineNum">     200</span>              : # endif</span>
<span id="L201"><span class="lineNum">     201</span>              : #endif</span>
<span id="L202"><span class="lineNum">     202</span>              : </span>
<span id="L203"><span class="lineNum">     203</span>              : #ifndef _GLIBCXX17_INLINE</span>
<span id="L204"><span class="lineNum">     204</span>              : # if __cplusplus &gt;= 201703L</span>
<span id="L205"><span class="lineNum">     205</span>              : #  define _GLIBCXX17_INLINE inline</span>
<span id="L206"><span class="lineNum">     206</span>              : # else</span>
<span id="L207"><span class="lineNum">     207</span>              : #  define _GLIBCXX17_INLINE</span>
<span id="L208"><span class="lineNum">     208</span>              : # endif</span>
<span id="L209"><span class="lineNum">     209</span>              : #endif</span>
<span id="L210"><span class="lineNum">     210</span>              : </span>
<span id="L211"><span class="lineNum">     211</span>              : // Macro for noexcept, to support in mixed 03/0x mode.</span>
<span id="L212"><span class="lineNum">     212</span>              : #ifndef _GLIBCXX_NOEXCEPT</span>
<span id="L213"><span class="lineNum">     213</span>              : # if __cplusplus &gt;= 201103L</span>
<span id="L214"><span class="lineNum">     214</span>              : #  define _GLIBCXX_NOEXCEPT noexcept</span>
<span id="L215"><span class="lineNum">     215</span>              : #  define _GLIBCXX_NOEXCEPT_IF(...) noexcept(__VA_ARGS__)</span>
<span id="L216"><span class="lineNum">     216</span>              : #  define _GLIBCXX_USE_NOEXCEPT noexcept</span>
<span id="L217"><span class="lineNum">     217</span>              : #  define _GLIBCXX_THROW(_EXC)</span>
<span id="L218"><span class="lineNum">     218</span>              : # else</span>
<span id="L219"><span class="lineNum">     219</span>              : #  define _GLIBCXX_NOEXCEPT</span>
<span id="L220"><span class="lineNum">     220</span>              : #  define _GLIBCXX_NOEXCEPT_IF(...)</span>
<span id="L221"><span class="lineNum">     221</span>              : #  define _GLIBCXX_USE_NOEXCEPT throw()</span>
<span id="L222"><span class="lineNum">     222</span>              : #  define _GLIBCXX_THROW(_EXC) throw(_EXC)</span>
<span id="L223"><span class="lineNum">     223</span>              : # endif</span>
<span id="L224"><span class="lineNum">     224</span>              : #endif</span>
<span id="L225"><span class="lineNum">     225</span>              : </span>
<span id="L226"><span class="lineNum">     226</span>              : #ifndef _GLIBCXX_NOTHROW</span>
<span id="L227"><span class="lineNum">     227</span>              : # define _GLIBCXX_NOTHROW _GLIBCXX_USE_NOEXCEPT</span>
<span id="L228"><span class="lineNum">     228</span>              : #endif</span>
<span id="L229"><span class="lineNum">     229</span>              : </span>
<span id="L230"><span class="lineNum">     230</span>              : #ifndef _GLIBCXX_THROW_OR_ABORT</span>
<span id="L231"><span class="lineNum">     231</span>              : # if __cpp_exceptions</span>
<span id="L232"><span class="lineNum">     232</span>              : #  define _GLIBCXX_THROW_OR_ABORT(_EXC) (throw (_EXC))</span>
<span id="L233"><span class="lineNum">     233</span>              : # else</span>
<span id="L234"><span class="lineNum">     234</span>              : #  define _GLIBCXX_THROW_OR_ABORT(_EXC) (__builtin_abort())</span>
<span id="L235"><span class="lineNum">     235</span>              : # endif</span>
<span id="L236"><span class="lineNum">     236</span>              : #endif</span>
<span id="L237"><span class="lineNum">     237</span>              : </span>
<span id="L238"><span class="lineNum">     238</span>              : #if __cpp_noexcept_function_type</span>
<span id="L239"><span class="lineNum">     239</span>              : #define _GLIBCXX_NOEXCEPT_PARM , bool _NE</span>
<span id="L240"><span class="lineNum">     240</span>              : #define _GLIBCXX_NOEXCEPT_QUAL noexcept (_NE)</span>
<span id="L241"><span class="lineNum">     241</span>              : #else</span>
<span id="L242"><span class="lineNum">     242</span>              : #define _GLIBCXX_NOEXCEPT_PARM</span>
<span id="L243"><span class="lineNum">     243</span>              : #define _GLIBCXX_NOEXCEPT_QUAL</span>
<span id="L244"><span class="lineNum">     244</span>              : #endif</span>
<span id="L245"><span class="lineNum">     245</span>              : </span>
<span id="L246"><span class="lineNum">     246</span>              : // Macro for extern template, ie controlling template linkage via use</span>
<span id="L247"><span class="lineNum">     247</span>              : // of extern keyword on template declaration. As documented in the g++</span>
<span id="L248"><span class="lineNum">     248</span>              : // manual, it inhibits all implicit instantiations and is used</span>
<span id="L249"><span class="lineNum">     249</span>              : // throughout the library to avoid multiple weak definitions for</span>
<span id="L250"><span class="lineNum">     250</span>              : // required types that are already explicitly instantiated in the</span>
<span id="L251"><span class="lineNum">     251</span>              : // library binary. This substantially reduces the binary size of</span>
<span id="L252"><span class="lineNum">     252</span>              : // resulting executables.</span>
<span id="L253"><span class="lineNum">     253</span>              : // Special case: _GLIBCXX_EXTERN_TEMPLATE == -1 disallows extern</span>
<span id="L254"><span class="lineNum">     254</span>              : // templates only in basic_string, thus activating its debug-mode</span>
<span id="L255"><span class="lineNum">     255</span>              : // checks even at -O0.</span>
<span id="L256"><span class="lineNum">     256</span>              : # define _GLIBCXX_EXTERN_TEMPLATE 1</span>
<span id="L257"><span class="lineNum">     257</span>              : </span>
<span id="L258"><span class="lineNum">     258</span>              : /*</span>
<span id="L259"><span class="lineNum">     259</span>              :   Outline of libstdc++ namespaces.</span>
<span id="L260"><span class="lineNum">     260</span>              : </span>
<span id="L261"><span class="lineNum">     261</span>              :   namespace std</span>
<span id="L262"><span class="lineNum">     262</span>              :   {</span>
<span id="L263"><span class="lineNum">     263</span>              :     namespace __debug { }</span>
<span id="L264"><span class="lineNum">     264</span>              :     namespace __parallel { }</span>
<span id="L265"><span class="lineNum">     265</span>              :     namespace __cxx1998 { }</span>
<span id="L266"><span class="lineNum">     266</span>              : </span>
<span id="L267"><span class="lineNum">     267</span>              :     namespace __detail {</span>
<span id="L268"><span class="lineNum">     268</span>              :       namespace __variant { }                           // C++17</span>
<span id="L269"><span class="lineNum">     269</span>              :     }</span>
<span id="L270"><span class="lineNum">     270</span>              : </span>
<span id="L271"><span class="lineNum">     271</span>              :     namespace rel_ops { }</span>
<span id="L272"><span class="lineNum">     272</span>              : </span>
<span id="L273"><span class="lineNum">     273</span>              :     namespace tr1</span>
<span id="L274"><span class="lineNum">     274</span>              :     {</span>
<span id="L275"><span class="lineNum">     275</span>              :       namespace placeholders { }</span>
<span id="L276"><span class="lineNum">     276</span>              :       namespace regex_constants { }</span>
<span id="L277"><span class="lineNum">     277</span>              :       namespace __detail { }</span>
<span id="L278"><span class="lineNum">     278</span>              :     }</span>
<span id="L279"><span class="lineNum">     279</span>              : </span>
<span id="L280"><span class="lineNum">     280</span>              :     namespace tr2 { }</span>
<span id="L281"><span class="lineNum">     281</span>              :     </span>
<span id="L282"><span class="lineNum">     282</span>              :     namespace decimal { }</span>
<span id="L283"><span class="lineNum">     283</span>              : </span>
<span id="L284"><span class="lineNum">     284</span>              :     namespace chrono { }                                // C++11</span>
<span id="L285"><span class="lineNum">     285</span>              :     namespace placeholders { }                          // C++11</span>
<span id="L286"><span class="lineNum">     286</span>              :     namespace regex_constants { }                       // C++11</span>
<span id="L287"><span class="lineNum">     287</span>              :     namespace this_thread { }                           // C++11</span>
<span id="L288"><span class="lineNum">     288</span>              :     inline namespace literals {                         // C++14</span>
<span id="L289"><span class="lineNum">     289</span>              :       inline namespace chrono_literals { }              // C++14</span>
<span id="L290"><span class="lineNum">     290</span>              :       inline namespace complex_literals { }             // C++14</span>
<span id="L291"><span class="lineNum">     291</span>              :       inline namespace string_literals { }              // C++14</span>
<span id="L292"><span class="lineNum">     292</span>              :       inline namespace string_view_literals { }         // C++17</span>
<span id="L293"><span class="lineNum">     293</span>              :     }</span>
<span id="L294"><span class="lineNum">     294</span>              :   }</span>
<span id="L295"><span class="lineNum">     295</span>              : </span>
<span id="L296"><span class="lineNum">     296</span>              :   namespace abi { }</span>
<span id="L297"><span class="lineNum">     297</span>              : </span>
<span id="L298"><span class="lineNum">     298</span>              :   namespace __gnu_cxx</span>
<span id="L299"><span class="lineNum">     299</span>              :   {</span>
<span id="L300"><span class="lineNum">     300</span>              :     namespace __detail { }</span>
<span id="L301"><span class="lineNum">     301</span>              :   }</span>
<span id="L302"><span class="lineNum">     302</span>              : </span>
<span id="L303"><span class="lineNum">     303</span>              :   For full details see:</span>
<span id="L304"><span class="lineNum">     304</span>              :   http://gcc.gnu.org/onlinedocs/libstdc++/latest-doxygen/namespaces.html</span>
<span id="L305"><span class="lineNum">     305</span>              : */</span>
<span id="L306"><span class="lineNum">     306</span>              : namespace std</span>
<span id="L307"><span class="lineNum">     307</span>              : {</span>
<span id="L308"><span class="lineNum">     308</span>              :   typedef __SIZE_TYPE__         size_t;</span>
<span id="L309"><span class="lineNum">     309</span>              :   typedef __PTRDIFF_TYPE__      ptrdiff_t;</span>
<span id="L310"><span class="lineNum">     310</span>              : </span>
<span id="L311"><span class="lineNum">     311</span>              : #if __cplusplus &gt;= 201103L</span>
<span id="L312"><span class="lineNum">     312</span>              :   typedef decltype(nullptr)     nullptr_t;</span>
<span id="L313"><span class="lineNum">     313</span>              : #endif</span>
<span id="L314"><span class="lineNum">     314</span>              : </span>
<span id="L315"><span class="lineNum">     315</span>              : #pragma GCC visibility push(default)</span>
<span id="L316"><span class="lineNum">     316</span>              :   // This allows the library to terminate without including all of &lt;exception&gt;</span>
<span id="L317"><span class="lineNum">     317</span>              :   // and without making the declaration of std::terminate visible to users.</span>
<span id="L318"><span class="lineNum">     318</span>              :   extern &quot;C++&quot; __attribute__ ((__noreturn__, __always_inline__))</span>
<span id="L319"><span class="lineNum">     319</span>              :   inline void __terminate() _GLIBCXX_USE_NOEXCEPT</span>
<span id="L320"><span class="lineNum">     320</span>              :   {</span>
<span id="L321"><span class="lineNum">     321</span>              :     void terminate() _GLIBCXX_USE_NOEXCEPT __attribute__ ((__noreturn__));</span>
<span id="L322"><span class="lineNum">     322</span>              :     terminate();</span>
<span id="L323"><span class="lineNum">     323</span>              :   }</span>
<span id="L324"><span class="lineNum">     324</span>              : #pragma GCC visibility pop</span>
<span id="L325"><span class="lineNum">     325</span>              : }</span>
<span id="L326"><span class="lineNum">     326</span>              : </span>
<span id="L327"><span class="lineNum">     327</span>              : # define _GLIBCXX_USE_DUAL_ABI 1</span>
<span id="L328"><span class="lineNum">     328</span>              : </span>
<span id="L329"><span class="lineNum">     329</span>              : #if ! _GLIBCXX_USE_DUAL_ABI</span>
<span id="L330"><span class="lineNum">     330</span>              : // Ignore any pre-defined value of _GLIBCXX_USE_CXX11_ABI</span>
<span id="L331"><span class="lineNum">     331</span>              : # undef _GLIBCXX_USE_CXX11_ABI</span>
<span id="L332"><span class="lineNum">     332</span>              : #endif</span>
<span id="L333"><span class="lineNum">     333</span>              : </span>
<span id="L334"><span class="lineNum">     334</span>              : #ifndef _GLIBCXX_USE_CXX11_ABI</span>
<span id="L335"><span class="lineNum">     335</span>              : # define _GLIBCXX_USE_CXX11_ABI 1</span>
<span id="L336"><span class="lineNum">     336</span>              : #endif</span>
<span id="L337"><span class="lineNum">     337</span>              : </span>
<span id="L338"><span class="lineNum">     338</span>              : #if _GLIBCXX_USE_CXX11_ABI</span>
<span id="L339"><span class="lineNum">     339</span>              : namespace std</span>
<span id="L340"><span class="lineNum">     340</span>              : {</span>
<span id="L341"><span class="lineNum">     341</span>              :   inline namespace __cxx11 __attribute__((__abi_tag__ (&quot;cxx11&quot;))) { }</span>
<span id="L342"><span class="lineNum">     342</span>              : }</span>
<span id="L343"><span class="lineNum">     343</span>              : namespace __gnu_cxx</span>
<span id="L344"><span class="lineNum">     344</span>              : {</span>
<span id="L345"><span class="lineNum">     345</span>              :   inline namespace __cxx11 __attribute__((__abi_tag__ (&quot;cxx11&quot;))) { }</span>
<span id="L346"><span class="lineNum">     346</span>              : }</span>
<span id="L347"><span class="lineNum">     347</span>              : # define _GLIBCXX_NAMESPACE_CXX11 __cxx11::</span>
<span id="L348"><span class="lineNum">     348</span>              : # define _GLIBCXX_BEGIN_NAMESPACE_CXX11 namespace __cxx11 {</span>
<span id="L349"><span class="lineNum">     349</span>              : # define _GLIBCXX_END_NAMESPACE_CXX11 }</span>
<span id="L350"><span class="lineNum">     350</span>              : # define _GLIBCXX_DEFAULT_ABI_TAG _GLIBCXX_ABI_TAG_CXX11</span>
<span id="L351"><span class="lineNum">     351</span>              : #else</span>
<span id="L352"><span class="lineNum">     352</span>              : # define _GLIBCXX_NAMESPACE_CXX11</span>
<span id="L353"><span class="lineNum">     353</span>              : # define _GLIBCXX_BEGIN_NAMESPACE_CXX11</span>
<span id="L354"><span class="lineNum">     354</span>              : # define _GLIBCXX_END_NAMESPACE_CXX11</span>
<span id="L355"><span class="lineNum">     355</span>              : # define _GLIBCXX_DEFAULT_ABI_TAG</span>
<span id="L356"><span class="lineNum">     356</span>              : #endif</span>
<span id="L357"><span class="lineNum">     357</span>              : </span>
<span id="L358"><span class="lineNum">     358</span>              : // Non-zero if inline namespaces are used for versioning the entire library.</span>
<span id="L359"><span class="lineNum">     359</span>              : # define _GLIBCXX_INLINE_VERSION 0 </span>
<span id="L360"><span class="lineNum">     360</span>              : </span>
<span id="L361"><span class="lineNum">     361</span>              : #if _GLIBCXX_INLINE_VERSION</span>
<span id="L362"><span class="lineNum">     362</span>              : // Inline namespace for symbol versioning of (nearly) everything in std.</span>
<span id="L363"><span class="lineNum">     363</span>              : # define _GLIBCXX_BEGIN_NAMESPACE_VERSION namespace __8 {</span>
<span id="L364"><span class="lineNum">     364</span>              : # define _GLIBCXX_END_NAMESPACE_VERSION }</span>
<span id="L365"><span class="lineNum">     365</span>              : // Unused when everything in std is versioned anyway.</span>
<span id="L366"><span class="lineNum">     366</span>              : # define _GLIBCXX_BEGIN_INLINE_ABI_NAMESPACE(X)</span>
<span id="L367"><span class="lineNum">     367</span>              : # define _GLIBCXX_END_INLINE_ABI_NAMESPACE(X)</span>
<span id="L368"><span class="lineNum">     368</span>              : </span>
<span id="L369"><span class="lineNum">     369</span>              : namespace std</span>
<span id="L370"><span class="lineNum">     370</span>              : {</span>
<span id="L371"><span class="lineNum">     371</span>              : inline _GLIBCXX_BEGIN_NAMESPACE_VERSION</span>
<span id="L372"><span class="lineNum">     372</span>              : #if __cplusplus &gt;= 201402L</span>
<span id="L373"><span class="lineNum">     373</span>              :   inline namespace literals {</span>
<span id="L374"><span class="lineNum">     374</span>              :     inline namespace chrono_literals { }</span>
<span id="L375"><span class="lineNum">     375</span>              :     inline namespace complex_literals { }</span>
<span id="L376"><span class="lineNum">     376</span>              :     inline namespace string_literals { }</span>
<span id="L377"><span class="lineNum">     377</span>              : #if __cplusplus &gt; 201402L</span>
<span id="L378"><span class="lineNum">     378</span>              :     inline namespace string_view_literals { }</span>
<span id="L379"><span class="lineNum">     379</span>              : #endif // C++17</span>
<span id="L380"><span class="lineNum">     380</span>              :   }</span>
<span id="L381"><span class="lineNum">     381</span>              : #endif // C++14</span>
<span id="L382"><span class="lineNum">     382</span>              : _GLIBCXX_END_NAMESPACE_VERSION</span>
<span id="L383"><span class="lineNum">     383</span>              : }</span>
<span id="L384"><span class="lineNum">     384</span>              : </span>
<span id="L385"><span class="lineNum">     385</span>              : namespace __gnu_cxx</span>
<span id="L386"><span class="lineNum">     386</span>              : {</span>
<span id="L387"><span class="lineNum">     387</span>              : inline _GLIBCXX_BEGIN_NAMESPACE_VERSION</span>
<span id="L388"><span class="lineNum">     388</span>              : _GLIBCXX_END_NAMESPACE_VERSION</span>
<span id="L389"><span class="lineNum">     389</span>              : }</span>
<span id="L390"><span class="lineNum">     390</span>              : </span>
<span id="L391"><span class="lineNum">     391</span>              : #else</span>
<span id="L392"><span class="lineNum">     392</span>              : // Unused.</span>
<span id="L393"><span class="lineNum">     393</span>              : # define _GLIBCXX_BEGIN_NAMESPACE_VERSION</span>
<span id="L394"><span class="lineNum">     394</span>              : # define _GLIBCXX_END_NAMESPACE_VERSION</span>
<span id="L395"><span class="lineNum">     395</span>              : // Used to version individual components, e.g. std::_V2::error_category.</span>
<span id="L396"><span class="lineNum">     396</span>              : # define _GLIBCXX_BEGIN_INLINE_ABI_NAMESPACE(X) inline namespace X {</span>
<span id="L397"><span class="lineNum">     397</span>              : # define _GLIBCXX_END_INLINE_ABI_NAMESPACE(X)   } // inline namespace X</span>
<span id="L398"><span class="lineNum">     398</span>              : #endif</span>
<span id="L399"><span class="lineNum">     399</span>              : </span>
<span id="L400"><span class="lineNum">     400</span>              : // In the case that we don't have a hosted environment, we can't provide the</span>
<span id="L401"><span class="lineNum">     401</span>              : // debugging mode.  Instead, we do our best and downgrade to assertions.</span>
<span id="L402"><span class="lineNum">     402</span>              : #if defined(_GLIBCXX_DEBUG) &amp;&amp; !__STDC_HOSTED__</span>
<span id="L403"><span class="lineNum">     403</span>              : #undef _GLIBCXX_DEBUG</span>
<span id="L404"><span class="lineNum">     404</span>              : #define _GLIBCXX_ASSERTIONS 1</span>
<span id="L405"><span class="lineNum">     405</span>              : #endif</span>
<span id="L406"><span class="lineNum">     406</span>              : </span>
<span id="L407"><span class="lineNum">     407</span>              : // Inline namespaces for special modes: debug, parallel.</span>
<span id="L408"><span class="lineNum">     408</span>              : #if defined(_GLIBCXX_DEBUG) || defined(_GLIBCXX_PARALLEL)</span>
<span id="L409"><span class="lineNum">     409</span>              : namespace std</span>
<span id="L410"><span class="lineNum">     410</span>              : {</span>
<span id="L411"><span class="lineNum">     411</span>              : _GLIBCXX_BEGIN_NAMESPACE_VERSION</span>
<span id="L412"><span class="lineNum">     412</span>              : </span>
<span id="L413"><span class="lineNum">     413</span>              :   // Non-inline namespace for components replaced by alternates in active mode.</span>
<span id="L414"><span class="lineNum">     414</span>              :   namespace __cxx1998</span>
<span id="L415"><span class="lineNum">     415</span>              :   {</span>
<span id="L416"><span class="lineNum">     416</span>              : # if _GLIBCXX_USE_CXX11_ABI</span>
<span id="L417"><span class="lineNum">     417</span>              :   inline namespace __cxx11 __attribute__((__abi_tag__ (&quot;cxx11&quot;))) { }</span>
<span id="L418"><span class="lineNum">     418</span>              : # endif</span>
<span id="L419"><span class="lineNum">     419</span>              :   }</span>
<span id="L420"><span class="lineNum">     420</span>              : </span>
<span id="L421"><span class="lineNum">     421</span>              : _GLIBCXX_END_NAMESPACE_VERSION</span>
<span id="L422"><span class="lineNum">     422</span>              : </span>
<span id="L423"><span class="lineNum">     423</span>              :   // Inline namespace for debug mode.</span>
<span id="L424"><span class="lineNum">     424</span>              : # ifdef _GLIBCXX_DEBUG</span>
<span id="L425"><span class="lineNum">     425</span>              :   inline namespace __debug { }</span>
<span id="L426"><span class="lineNum">     426</span>              : # endif</span>
<span id="L427"><span class="lineNum">     427</span>              : </span>
<span id="L428"><span class="lineNum">     428</span>              :   // Inline namespaces for parallel mode.</span>
<span id="L429"><span class="lineNum">     429</span>              : # ifdef _GLIBCXX_PARALLEL</span>
<span id="L430"><span class="lineNum">     430</span>              :   inline namespace __parallel { }</span>
<span id="L431"><span class="lineNum">     431</span>              : # endif</span>
<span id="L432"><span class="lineNum">     432</span>              : }</span>
<span id="L433"><span class="lineNum">     433</span>              : </span>
<span id="L434"><span class="lineNum">     434</span>              : // Check for invalid usage and unsupported mixed-mode use.</span>
<span id="L435"><span class="lineNum">     435</span>              : # if defined(_GLIBCXX_DEBUG) &amp;&amp; defined(_GLIBCXX_PARALLEL)</span>
<span id="L436"><span class="lineNum">     436</span>              : #  error illegal use of multiple inlined namespaces</span>
<span id="L437"><span class="lineNum">     437</span>              : # endif</span>
<span id="L438"><span class="lineNum">     438</span>              : </span>
<span id="L439"><span class="lineNum">     439</span>              : // Check for invalid use due to lack for weak symbols.</span>
<span id="L440"><span class="lineNum">     440</span>              : # if __NO_INLINE__ &amp;&amp; !__GXX_WEAK__</span>
<span id="L441"><span class="lineNum">     441</span>              : #  warning currently using inlined namespace mode which may fail \</span>
<span id="L442"><span class="lineNum">     442</span>              :    without inlining due to lack of weak symbols</span>
<span id="L443"><span class="lineNum">     443</span>              : # endif</span>
<span id="L444"><span class="lineNum">     444</span>              : #endif</span>
<span id="L445"><span class="lineNum">     445</span>              : </span>
<span id="L446"><span class="lineNum">     446</span>              : // Macros for namespace scope. Either namespace std:: or the name</span>
<span id="L447"><span class="lineNum">     447</span>              : // of some nested namespace within it corresponding to the active mode.</span>
<span id="L448"><span class="lineNum">     448</span>              : // _GLIBCXX_STD_A</span>
<span id="L449"><span class="lineNum">     449</span>              : // _GLIBCXX_STD_C</span>
<span id="L450"><span class="lineNum">     450</span>              : //</span>
<span id="L451"><span class="lineNum">     451</span>              : // Macros for opening/closing conditional namespaces.</span>
<span id="L452"><span class="lineNum">     452</span>              : // _GLIBCXX_BEGIN_NAMESPACE_ALGO</span>
<span id="L453"><span class="lineNum">     453</span>              : // _GLIBCXX_END_NAMESPACE_ALGO</span>
<span id="L454"><span class="lineNum">     454</span>              : // _GLIBCXX_BEGIN_NAMESPACE_CONTAINER</span>
<span id="L455"><span class="lineNum">     455</span>              : // _GLIBCXX_END_NAMESPACE_CONTAINER</span>
<span id="L456"><span class="lineNum">     456</span>              : #if defined(_GLIBCXX_DEBUG)</span>
<span id="L457"><span class="lineNum">     457</span>              : # define _GLIBCXX_STD_C __cxx1998</span>
<span id="L458"><span class="lineNum">     458</span>              : # define _GLIBCXX_BEGIN_NAMESPACE_CONTAINER \</span>
<span id="L459"><span class="lineNum">     459</span>              :          namespace _GLIBCXX_STD_C {</span>
<span id="L460"><span class="lineNum">     460</span>              : # define _GLIBCXX_END_NAMESPACE_CONTAINER }</span>
<span id="L461"><span class="lineNum">     461</span>              : #else</span>
<span id="L462"><span class="lineNum">     462</span>              : # define _GLIBCXX_STD_C std</span>
<span id="L463"><span class="lineNum">     463</span>              : # define _GLIBCXX_BEGIN_NAMESPACE_CONTAINER</span>
<span id="L464"><span class="lineNum">     464</span>              : # define _GLIBCXX_END_NAMESPACE_CONTAINER</span>
<span id="L465"><span class="lineNum">     465</span>              : #endif</span>
<span id="L466"><span class="lineNum">     466</span>              : </span>
<span id="L467"><span class="lineNum">     467</span>              : #ifdef _GLIBCXX_PARALLEL</span>
<span id="L468"><span class="lineNum">     468</span>              : # define _GLIBCXX_STD_A __cxx1998</span>
<span id="L469"><span class="lineNum">     469</span>              : # define _GLIBCXX_BEGIN_NAMESPACE_ALGO \</span>
<span id="L470"><span class="lineNum">     470</span>              :          namespace _GLIBCXX_STD_A {</span>
<span id="L471"><span class="lineNum">     471</span>              : # define _GLIBCXX_END_NAMESPACE_ALGO }</span>
<span id="L472"><span class="lineNum">     472</span>              : #else</span>
<span id="L473"><span class="lineNum">     473</span>              : # define _GLIBCXX_STD_A std</span>
<span id="L474"><span class="lineNum">     474</span>              : # define _GLIBCXX_BEGIN_NAMESPACE_ALGO</span>
<span id="L475"><span class="lineNum">     475</span>              : # define _GLIBCXX_END_NAMESPACE_ALGO</span>
<span id="L476"><span class="lineNum">     476</span>              : #endif</span>
<span id="L477"><span class="lineNum">     477</span>              : </span>
<span id="L478"><span class="lineNum">     478</span>              : // GLIBCXX_ABI Deprecated</span>
<span id="L479"><span class="lineNum">     479</span>              : // Define if compatibility should be provided for -mlong-double-64.</span>
<span id="L480"><span class="lineNum">     480</span>              : #undef _GLIBCXX_LONG_DOUBLE_COMPAT</span>
<span id="L481"><span class="lineNum">     481</span>              : </span>
<span id="L482"><span class="lineNum">     482</span>              : // Define if compatibility should be provided for alternative 128-bit long</span>
<span id="L483"><span class="lineNum">     483</span>              : // double formats. Not possible for Clang until __ibm128 is supported.</span>
<span id="L484"><span class="lineNum">     484</span>              : #ifndef __clang__</span>
<span id="L485"><span class="lineNum">     485</span>              : #undef _GLIBCXX_LONG_DOUBLE_ALT128_COMPAT</span>
<span id="L486"><span class="lineNum">     486</span>              : #endif</span>
<span id="L487"><span class="lineNum">     487</span>              : </span>
<span id="L488"><span class="lineNum">     488</span>              : // Inline namespaces for long double 128 modes.</span>
<span id="L489"><span class="lineNum">     489</span>              : #if defined _GLIBCXX_LONG_DOUBLE_ALT128_COMPAT \</span>
<span id="L490"><span class="lineNum">     490</span>              :   &amp;&amp; defined __LONG_DOUBLE_IEEE128__</span>
<span id="L491"><span class="lineNum">     491</span>              : namespace std</span>
<span id="L492"><span class="lineNum">     492</span>              : {</span>
<span id="L493"><span class="lineNum">     493</span>              :   // Namespaces for 128-bit IEEE long double format on 64-bit POWER LE.</span>
<span id="L494"><span class="lineNum">     494</span>              :   inline namespace __gnu_cxx_ieee128 { }</span>
<span id="L495"><span class="lineNum">     495</span>              :   inline namespace __gnu_cxx11_ieee128 { }</span>
<span id="L496"><span class="lineNum">     496</span>              : }</span>
<span id="L497"><span class="lineNum">     497</span>              : # define _GLIBCXX_NAMESPACE_LDBL __gnu_cxx_ieee128::</span>
<span id="L498"><span class="lineNum">     498</span>              : # define _GLIBCXX_BEGIN_NAMESPACE_LDBL namespace __gnu_cxx_ieee128 {</span>
<span id="L499"><span class="lineNum">     499</span>              : # define _GLIBCXX_END_NAMESPACE_LDBL }</span>
<span id="L500"><span class="lineNum">     500</span>              : # define _GLIBCXX_NAMESPACE_LDBL_OR_CXX11 __gnu_cxx11_ieee128::</span>
<span id="L501"><span class="lineNum">     501</span>              : # define _GLIBCXX_BEGIN_NAMESPACE_LDBL_OR_CXX11 namespace __gnu_cxx11_ieee128 {</span>
<span id="L502"><span class="lineNum">     502</span>              : # define _GLIBCXX_END_NAMESPACE_LDBL_OR_CXX11 }</span>
<span id="L503"><span class="lineNum">     503</span>              : </span>
<span id="L504"><span class="lineNum">     504</span>              : #else // _GLIBCXX_LONG_DOUBLE_ALT128_COMPAT &amp;&amp; IEEE128</span>
<span id="L505"><span class="lineNum">     505</span>              : </span>
<span id="L506"><span class="lineNum">     506</span>              : #if defined _GLIBCXX_LONG_DOUBLE_COMPAT &amp;&amp; defined __LONG_DOUBLE_128__</span>
<span id="L507"><span class="lineNum">     507</span>              : namespace std</span>
<span id="L508"><span class="lineNum">     508</span>              : {</span>
<span id="L509"><span class="lineNum">     509</span>              :   inline namespace __gnu_cxx_ldbl128 { }</span>
<span id="L510"><span class="lineNum">     510</span>              : }</span>
<span id="L511"><span class="lineNum">     511</span>              : # define _GLIBCXX_NAMESPACE_LDBL __gnu_cxx_ldbl128::</span>
<span id="L512"><span class="lineNum">     512</span>              : # define _GLIBCXX_BEGIN_NAMESPACE_LDBL namespace __gnu_cxx_ldbl128 {</span>
<span id="L513"><span class="lineNum">     513</span>              : # define _GLIBCXX_END_NAMESPACE_LDBL }</span>
<span id="L514"><span class="lineNum">     514</span>              : #else</span>
<span id="L515"><span class="lineNum">     515</span>              : # define _GLIBCXX_NAMESPACE_LDBL</span>
<span id="L516"><span class="lineNum">     516</span>              : # define _GLIBCXX_BEGIN_NAMESPACE_LDBL</span>
<span id="L517"><span class="lineNum">     517</span>              : # define _GLIBCXX_END_NAMESPACE_LDBL</span>
<span id="L518"><span class="lineNum">     518</span>              : #endif</span>
<span id="L519"><span class="lineNum">     519</span>              : </span>
<span id="L520"><span class="lineNum">     520</span>              : #if _GLIBCXX_USE_CXX11_ABI</span>
<span id="L521"><span class="lineNum">     521</span>              : # define _GLIBCXX_NAMESPACE_LDBL_OR_CXX11 _GLIBCXX_NAMESPACE_CXX11</span>
<span id="L522"><span class="lineNum">     522</span>              : # define _GLIBCXX_BEGIN_NAMESPACE_LDBL_OR_CXX11 _GLIBCXX_BEGIN_NAMESPACE_CXX11</span>
<span id="L523"><span class="lineNum">     523</span>              : # define _GLIBCXX_END_NAMESPACE_LDBL_OR_CXX11 _GLIBCXX_END_NAMESPACE_CXX11</span>
<span id="L524"><span class="lineNum">     524</span>              : #else</span>
<span id="L525"><span class="lineNum">     525</span>              : # define _GLIBCXX_NAMESPACE_LDBL_OR_CXX11 _GLIBCXX_NAMESPACE_LDBL</span>
<span id="L526"><span class="lineNum">     526</span>              : # define _GLIBCXX_BEGIN_NAMESPACE_LDBL_OR_CXX11 _GLIBCXX_BEGIN_NAMESPACE_LDBL</span>
<span id="L527"><span class="lineNum">     527</span>              : # define _GLIBCXX_END_NAMESPACE_LDBL_OR_CXX11 _GLIBCXX_END_NAMESPACE_LDBL</span>
<span id="L528"><span class="lineNum">     528</span>              : #endif</span>
<span id="L529"><span class="lineNum">     529</span>              : </span>
<span id="L530"><span class="lineNum">     530</span>              : #endif // _GLIBCXX_LONG_DOUBLE_ALT128_COMPAT &amp;&amp; IEEE128</span>
<span id="L531"><span class="lineNum">     531</span>              : </span>
<span id="L532"><span class="lineNum">     532</span>              : namespace std</span>
<span id="L533"><span class="lineNum">     533</span>              : {</span>
<span id="L534"><span class="lineNum">     534</span>              : #pragma GCC visibility push(default)</span>
<span id="L535"><span class="lineNum">     535</span>              :   // Internal version of std::is_constant_evaluated().</span>
<span id="L536"><span class="lineNum">     536</span>              :   // This can be used without checking if the compiler supports the feature.</span>
<span id="L537"><span class="lineNum">     537</span>              :   // The macro _GLIBCXX_HAVE_IS_CONSTANT_EVALUATED can be used to check if</span>
<span id="L538"><span class="lineNum">     538</span>              :   // the compiler support is present to make this function work as expected.</span>
<span id="L539"><span class="lineNum">     539</span>              :   _GLIBCXX_CONSTEXPR inline bool</span>
<span id="L540"><span class="lineNum">     540</span> <span class="tlaGNC tlaBgGNC">         637 :   __is_constant_evaluated() _GLIBCXX_NOEXCEPT</span></span>
<span id="L541"><span class="lineNum">     541</span>              :   {</span>
<span id="L542"><span class="lineNum">     542</span>              : #if __cpp_if_consteval &gt;= 202106L</span>
<span id="L543"><span class="lineNum">     543</span>              : # define _GLIBCXX_HAVE_IS_CONSTANT_EVALUATED 1</span>
<span id="L544"><span class="lineNum">     544</span>              :     if consteval { return true; } else { return false; }</span>
<span id="L545"><span class="lineNum">     545</span>              : #elif __cplusplus &gt;= 201103L &amp;&amp; __has_builtin(__builtin_is_constant_evaluated)</span>
<span id="L546"><span class="lineNum">     546</span>              : # define _GLIBCXX_HAVE_IS_CONSTANT_EVALUATED 1</span>
<span id="L547"><span class="lineNum">     547</span> <span class="tlaGNC">         637 :     return __builtin_is_constant_evaluated();</span></span>
<span id="L548"><span class="lineNum">     548</span>              : #else</span>
<span id="L549"><span class="lineNum">     549</span>              :     return false;</span>
<span id="L550"><span class="lineNum">     550</span>              : #endif</span>
<span id="L551"><span class="lineNum">     551</span>              :   }</span>
<span id="L552"><span class="lineNum">     552</span>              : #pragma GCC visibility pop</span>
<span id="L553"><span class="lineNum">     553</span>              : }</span>
<span id="L554"><span class="lineNum">     554</span>              : </span>
<span id="L555"><span class="lineNum">     555</span>              : // Debug Mode implies checking assertions.</span>
<span id="L556"><span class="lineNum">     556</span>              : #if defined(_GLIBCXX_DEBUG) &amp;&amp; !defined(_GLIBCXX_ASSERTIONS)</span>
<span id="L557"><span class="lineNum">     557</span>              : # define _GLIBCXX_ASSERTIONS 1</span>
<span id="L558"><span class="lineNum">     558</span>              : #endif</span>
<span id="L559"><span class="lineNum">     559</span>              : </span>
<span id="L560"><span class="lineNum">     560</span>              : // Disable std::string explicit instantiation declarations in order to assert.</span>
<span id="L561"><span class="lineNum">     561</span>              : #ifdef _GLIBCXX_ASSERTIONS</span>
<span id="L562"><span class="lineNum">     562</span>              : # undef _GLIBCXX_EXTERN_TEMPLATE</span>
<span id="L563"><span class="lineNum">     563</span>              : # define _GLIBCXX_EXTERN_TEMPLATE -1</span>
<span id="L564"><span class="lineNum">     564</span>              : #endif</span>
<span id="L565"><span class="lineNum">     565</span>              : </span>
<span id="L566"><span class="lineNum">     566</span>              : </span>
<span id="L567"><span class="lineNum">     567</span>              : #if _GLIBCXX_HAVE_IS_CONSTANT_EVALUATED</span>
<span id="L568"><span class="lineNum">     568</span>              : # define __glibcxx_constexpr_assert(cond) \</span>
<span id="L569"><span class="lineNum">     569</span>              :   if (std::__is_constant_evaluated() &amp;&amp; !bool(cond))    \</span>
<span id="L570"><span class="lineNum">     570</span>              :     __builtin_unreachable() /* precondition violation detected! */</span>
<span id="L571"><span class="lineNum">     571</span>              : #else</span>
<span id="L572"><span class="lineNum">     572</span>              : # define __glibcxx_constexpr_assert(unevaluated)</span>
<span id="L573"><span class="lineNum">     573</span>              : #endif</span>
<span id="L574"><span class="lineNum">     574</span>              : </span>
<span id="L575"><span class="lineNum">     575</span>              : #define _GLIBCXX_VERBOSE_ASSERT 1</span>
<span id="L576"><span class="lineNum">     576</span>              : </span>
<span id="L577"><span class="lineNum">     577</span>              : // Assert.</span>
<span id="L578"><span class="lineNum">     578</span>              : #if defined(_GLIBCXX_ASSERTIONS) \</span>
<span id="L579"><span class="lineNum">     579</span>              :   || defined(_GLIBCXX_PARALLEL) || defined(_GLIBCXX_PARALLEL_ASSERTIONS)</span>
<span id="L580"><span class="lineNum">     580</span>              : # ifdef _GLIBCXX_VERBOSE_ASSERT</span>
<span id="L581"><span class="lineNum">     581</span>              : namespace std</span>
<span id="L582"><span class="lineNum">     582</span>              : {</span>
<span id="L583"><span class="lineNum">     583</span>              : #pragma GCC visibility push(default)</span>
<span id="L584"><span class="lineNum">     584</span>              :   // Avoid the use of assert, because we're trying to keep the &lt;cassert&gt;</span>
<span id="L585"><span class="lineNum">     585</span>              :   // include out of the mix.</span>
<span id="L586"><span class="lineNum">     586</span>              :   extern &quot;C++&quot; _GLIBCXX_NORETURN</span>
<span id="L587"><span class="lineNum">     587</span>              :   void</span>
<span id="L588"><span class="lineNum">     588</span>              :   __glibcxx_assert_fail(const char* __file, int __line,</span>
<span id="L589"><span class="lineNum">     589</span>              :                         const char* __function, const char* __condition)</span>
<span id="L590"><span class="lineNum">     590</span>              :   _GLIBCXX_NOEXCEPT;</span>
<span id="L591"><span class="lineNum">     591</span>              : #pragma GCC visibility pop</span>
<span id="L592"><span class="lineNum">     592</span>              : }</span>
<span id="L593"><span class="lineNum">     593</span>              : #define __glibcxx_assert_impl(_Condition)                               \</span>
<span id="L594"><span class="lineNum">     594</span>              :   if (__builtin_expect(!bool(_Condition), false))                       \</span>
<span id="L595"><span class="lineNum">     595</span>              :   {                                                                     \</span>
<span id="L596"><span class="lineNum">     596</span>              :     __glibcxx_constexpr_assert(false);                                  \</span>
<span id="L597"><span class="lineNum">     597</span>              :     std::__glibcxx_assert_fail(__FILE__, __LINE__, __PRETTY_FUNCTION__, \</span>
<span id="L598"><span class="lineNum">     598</span>              :                                #_Condition);                            \</span>
<span id="L599"><span class="lineNum">     599</span>              :   }</span>
<span id="L600"><span class="lineNum">     600</span>              : # else // ! VERBOSE_ASSERT</span>
<span id="L601"><span class="lineNum">     601</span>              : # define __glibcxx_assert_impl(_Condition)              \</span>
<span id="L602"><span class="lineNum">     602</span>              :   if (__builtin_expect(!bool(_Condition), false))       \</span>
<span id="L603"><span class="lineNum">     603</span>              :   {                                                     \</span>
<span id="L604"><span class="lineNum">     604</span>              :     __glibcxx_constexpr_assert(false);                  \</span>
<span id="L605"><span class="lineNum">     605</span>              :     __builtin_abort();                                  \</span>
<span id="L606"><span class="lineNum">     606</span>              :   }</span>
<span id="L607"><span class="lineNum">     607</span>              : # endif</span>
<span id="L608"><span class="lineNum">     608</span>              : #endif</span>
<span id="L609"><span class="lineNum">     609</span>              : </span>
<span id="L610"><span class="lineNum">     610</span>              : #if defined(_GLIBCXX_ASSERTIONS)</span>
<span id="L611"><span class="lineNum">     611</span>              : # define __glibcxx_assert(cond) \</span>
<span id="L612"><span class="lineNum">     612</span>              :   do { __glibcxx_assert_impl(cond); } while (false)</span>
<span id="L613"><span class="lineNum">     613</span>              : #else</span>
<span id="L614"><span class="lineNum">     614</span>              : # define __glibcxx_assert(cond) \</span>
<span id="L615"><span class="lineNum">     615</span>              :   do { __glibcxx_constexpr_assert(cond); } while (false)</span>
<span id="L616"><span class="lineNum">     616</span>              : #endif</span>
<span id="L617"><span class="lineNum">     617</span>              : </span>
<span id="L618"><span class="lineNum">     618</span>              : // Macro indicating that TSAN is in use.</span>
<span id="L619"><span class="lineNum">     619</span>              : #if __SANITIZE_THREAD__</span>
<span id="L620"><span class="lineNum">     620</span>              : #  define _GLIBCXX_TSAN 1</span>
<span id="L621"><span class="lineNum">     621</span>              : #elif defined __has_feature</span>
<span id="L622"><span class="lineNum">     622</span>              : # if __has_feature(thread_sanitizer)</span>
<span id="L623"><span class="lineNum">     623</span>              : #  define _GLIBCXX_TSAN 1</span>
<span id="L624"><span class="lineNum">     624</span>              : # endif</span>
<span id="L625"><span class="lineNum">     625</span>              : #endif</span>
<span id="L626"><span class="lineNum">     626</span>              : </span>
<span id="L627"><span class="lineNum">     627</span>              : // Macros for race detectors.</span>
<span id="L628"><span class="lineNum">     628</span>              : // _GLIBCXX_SYNCHRONIZATION_HAPPENS_BEFORE(A) and</span>
<span id="L629"><span class="lineNum">     629</span>              : // _GLIBCXX_SYNCHRONIZATION_HAPPENS_AFTER(A) should be used to explain</span>
<span id="L630"><span class="lineNum">     630</span>              : // atomic (lock-free) synchronization to race detectors:</span>
<span id="L631"><span class="lineNum">     631</span>              : // the race detector will infer a happens-before arc from the former to the</span>
<span id="L632"><span class="lineNum">     632</span>              : // latter when they share the same argument pointer.</span>
<span id="L633"><span class="lineNum">     633</span>              : //</span>
<span id="L634"><span class="lineNum">     634</span>              : // The most frequent use case for these macros (and the only case in the</span>
<span id="L635"><span class="lineNum">     635</span>              : // current implementation of the library) is atomic reference counting:</span>
<span id="L636"><span class="lineNum">     636</span>              : //   void _M_remove_reference()</span>
<span id="L637"><span class="lineNum">     637</span>              : //   {</span>
<span id="L638"><span class="lineNum">     638</span>              : //     _GLIBCXX_SYNCHRONIZATION_HAPPENS_BEFORE(&amp;this-&gt;_M_refcount);</span>
<span id="L639"><span class="lineNum">     639</span>              : //     if (__gnu_cxx::__exchange_and_add_dispatch(&amp;this-&gt;_M_refcount, -1) &lt;= 0)</span>
<span id="L640"><span class="lineNum">     640</span>              : //       {</span>
<span id="L641"><span class="lineNum">     641</span>              : //         _GLIBCXX_SYNCHRONIZATION_HAPPENS_AFTER(&amp;this-&gt;_M_refcount);</span>
<span id="L642"><span class="lineNum">     642</span>              : //         _M_destroy(__a);</span>
<span id="L643"><span class="lineNum">     643</span>              : //       }</span>
<span id="L644"><span class="lineNum">     644</span>              : //   }</span>
<span id="L645"><span class="lineNum">     645</span>              : // The annotations in this example tell the race detector that all memory</span>
<span id="L646"><span class="lineNum">     646</span>              : // accesses occurred when the refcount was positive do not race with</span>
<span id="L647"><span class="lineNum">     647</span>              : // memory accesses which occurred after the refcount became zero.</span>
<span id="L648"><span class="lineNum">     648</span>              : #ifndef _GLIBCXX_SYNCHRONIZATION_HAPPENS_BEFORE</span>
<span id="L649"><span class="lineNum">     649</span>              : # define  _GLIBCXX_SYNCHRONIZATION_HAPPENS_BEFORE(A)</span>
<span id="L650"><span class="lineNum">     650</span>              : #endif</span>
<span id="L651"><span class="lineNum">     651</span>              : #ifndef _GLIBCXX_SYNCHRONIZATION_HAPPENS_AFTER</span>
<span id="L652"><span class="lineNum">     652</span>              : # define  _GLIBCXX_SYNCHRONIZATION_HAPPENS_AFTER(A)</span>
<span id="L653"><span class="lineNum">     653</span>              : #endif</span>
<span id="L654"><span class="lineNum">     654</span>              : </span>
<span id="L655"><span class="lineNum">     655</span>              : // Macros for C linkage: define extern &quot;C&quot; linkage only when using C++.</span>
<span id="L656"><span class="lineNum">     656</span>              : # define _GLIBCXX_BEGIN_EXTERN_C extern &quot;C&quot; {</span>
<span id="L657"><span class="lineNum">     657</span>              : # define _GLIBCXX_END_EXTERN_C }</span>
<span id="L658"><span class="lineNum">     658</span>              : </span>
<span id="L659"><span class="lineNum">     659</span>              : # define _GLIBCXX_USE_ALLOCATOR_NEW 1</span>
<span id="L660"><span class="lineNum">     660</span>              : </span>
<span id="L661"><span class="lineNum">     661</span>              : #ifdef __SIZEOF_INT128__</span>
<span id="L662"><span class="lineNum">     662</span>              : #if ! defined __GLIBCXX_TYPE_INT_N_0 &amp;&amp; ! defined __STRICT_ANSI__</span>
<span id="L663"><span class="lineNum">     663</span>              : // If __int128 is supported, we expect __GLIBCXX_TYPE_INT_N_0 to be defined</span>
<span id="L664"><span class="lineNum">     664</span>              : // unless the compiler is in strict mode. If it's not defined and the strict</span>
<span id="L665"><span class="lineNum">     665</span>              : // macro is not defined, something is wrong.</span>
<span id="L666"><span class="lineNum">     666</span>              : #warning &quot;__STRICT_ANSI__ seems to have been undefined; this is not supported&quot;</span>
<span id="L667"><span class="lineNum">     667</span>              : #endif</span>
<span id="L668"><span class="lineNum">     668</span>              : #endif</span>
<span id="L669"><span class="lineNum">     669</span>              : </span>
<span id="L670"><span class="lineNum">     670</span>              : #else // !__cplusplus</span>
<span id="L671"><span class="lineNum">     671</span>              : # define _GLIBCXX_BEGIN_EXTERN_C</span>
<span id="L672"><span class="lineNum">     672</span>              : # define _GLIBCXX_END_EXTERN_C</span>
<span id="L673"><span class="lineNum">     673</span>              : #endif</span>
<span id="L674"><span class="lineNum">     674</span>              : </span>
<span id="L675"><span class="lineNum">     675</span>              : </span>
<span id="L676"><span class="lineNum">     676</span>              : // First includes.</span>
<span id="L677"><span class="lineNum">     677</span>              : </span>
<span id="L678"><span class="lineNum">     678</span>              : // Pick up any OS-specific definitions.</span>
<span id="L679"><span class="lineNum">     679</span>              : #include &lt;bits/os_defines.h&gt;</span>
<span id="L680"><span class="lineNum">     680</span>              : </span>
<span id="L681"><span class="lineNum">     681</span>              : // Pick up any CPU-specific definitions.</span>
<span id="L682"><span class="lineNum">     682</span>              : #include &lt;bits/cpu_defines.h&gt;</span>
<span id="L683"><span class="lineNum">     683</span>              : </span>
<span id="L684"><span class="lineNum">     684</span>              : // If platform uses neither visibility nor psuedo-visibility,</span>
<span id="L685"><span class="lineNum">     685</span>              : // specify empty default for namespace annotation macros.</span>
<span id="L686"><span class="lineNum">     686</span>              : #ifndef _GLIBCXX_PSEUDO_VISIBILITY</span>
<span id="L687"><span class="lineNum">     687</span>              : # define _GLIBCXX_PSEUDO_VISIBILITY(V)</span>
<span id="L688"><span class="lineNum">     688</span>              : #endif</span>
<span id="L689"><span class="lineNum">     689</span>              : </span>
<span id="L690"><span class="lineNum">     690</span>              : // Certain function definitions that are meant to be overridable from</span>
<span id="L691"><span class="lineNum">     691</span>              : // user code are decorated with this macro.  For some targets, this</span>
<span id="L692"><span class="lineNum">     692</span>              : // macro causes these definitions to be weak.</span>
<span id="L693"><span class="lineNum">     693</span>              : #ifndef _GLIBCXX_WEAK_DEFINITION</span>
<span id="L694"><span class="lineNum">     694</span>              : # define _GLIBCXX_WEAK_DEFINITION</span>
<span id="L695"><span class="lineNum">     695</span>              : #endif</span>
<span id="L696"><span class="lineNum">     696</span>              : </span>
<span id="L697"><span class="lineNum">     697</span>              : // By default, we assume that __GXX_WEAK__ also means that there is support</span>
<span id="L698"><span class="lineNum">     698</span>              : // for declaring functions as weak while not defining such functions.  This</span>
<span id="L699"><span class="lineNum">     699</span>              : // allows for referring to functions provided by other libraries (e.g.,</span>
<span id="L700"><span class="lineNum">     700</span>              : // libitm) without depending on them if the respective features are not used.</span>
<span id="L701"><span class="lineNum">     701</span>              : #ifndef _GLIBCXX_USE_WEAK_REF</span>
<span id="L702"><span class="lineNum">     702</span>              : # define _GLIBCXX_USE_WEAK_REF __GXX_WEAK__</span>
<span id="L703"><span class="lineNum">     703</span>              : #endif</span>
<span id="L704"><span class="lineNum">     704</span>              : </span>
<span id="L705"><span class="lineNum">     705</span>              : // Conditionally enable annotations for the Transactional Memory TS on C++11.</span>
<span id="L706"><span class="lineNum">     706</span>              : // Most of the following conditions are due to limitations in the current</span>
<span id="L707"><span class="lineNum">     707</span>              : // implementation.</span>
<span id="L708"><span class="lineNum">     708</span>              : #if __cplusplus &gt;= 201103L &amp;&amp; _GLIBCXX_USE_CXX11_ABI                 \</span>
<span id="L709"><span class="lineNum">     709</span>              :   &amp;&amp; _GLIBCXX_USE_DUAL_ABI &amp;&amp; __cpp_transactional_memory &gt;= 201500L  \</span>
<span id="L710"><span class="lineNum">     710</span>              :   &amp;&amp;  !_GLIBCXX_FULLY_DYNAMIC_STRING &amp;&amp; _GLIBCXX_USE_WEAK_REF           \</span>
<span id="L711"><span class="lineNum">     711</span>              :   &amp;&amp; _GLIBCXX_USE_ALLOCATOR_NEW</span>
<span id="L712"><span class="lineNum">     712</span>              : #define _GLIBCXX_TXN_SAFE transaction_safe</span>
<span id="L713"><span class="lineNum">     713</span>              : #define _GLIBCXX_TXN_SAFE_DYN transaction_safe_dynamic</span>
<span id="L714"><span class="lineNum">     714</span>              : #else</span>
<span id="L715"><span class="lineNum">     715</span>              : #define _GLIBCXX_TXN_SAFE</span>
<span id="L716"><span class="lineNum">     716</span>              : #define _GLIBCXX_TXN_SAFE_DYN</span>
<span id="L717"><span class="lineNum">     717</span>              : #endif</span>
<span id="L718"><span class="lineNum">     718</span>              : </span>
<span id="L719"><span class="lineNum">     719</span>              : #if __cplusplus &gt; 201402L</span>
<span id="L720"><span class="lineNum">     720</span>              : // In C++17 mathematical special functions are in namespace std.</span>
<span id="L721"><span class="lineNum">     721</span>              : # define _GLIBCXX_USE_STD_SPEC_FUNCS 1</span>
<span id="L722"><span class="lineNum">     722</span>              : #elif __cplusplus &gt;= 201103L &amp;&amp; __STDCPP_WANT_MATH_SPEC_FUNCS__ != 0</span>
<span id="L723"><span class="lineNum">     723</span>              : // For C++11 and C++14 they are in namespace std when requested.</span>
<span id="L724"><span class="lineNum">     724</span>              : # define _GLIBCXX_USE_STD_SPEC_FUNCS 1</span>
<span id="L725"><span class="lineNum">     725</span>              : #endif</span>
<span id="L726"><span class="lineNum">     726</span>              : </span>
<span id="L727"><span class="lineNum">     727</span>              : // The remainder of the prewritten config is automatic; all the</span>
<span id="L728"><span class="lineNum">     728</span>              : // user hooks are listed above.</span>
<span id="L729"><span class="lineNum">     729</span>              : </span>
<span id="L730"><span class="lineNum">     730</span>              : // Create a boolean flag to be used to determine if --fast-math is set.</span>
<span id="L731"><span class="lineNum">     731</span>              : #ifdef __FAST_MATH__</span>
<span id="L732"><span class="lineNum">     732</span>              : # define _GLIBCXX_FAST_MATH 1</span>
<span id="L733"><span class="lineNum">     733</span>              : #else</span>
<span id="L734"><span class="lineNum">     734</span>              : # define _GLIBCXX_FAST_MATH 0</span>
<span id="L735"><span class="lineNum">     735</span>              : #endif</span>
<span id="L736"><span class="lineNum">     736</span>              : </span>
<span id="L737"><span class="lineNum">     737</span>              : // This marks string literals in header files to be extracted for eventual</span>
<span id="L738"><span class="lineNum">     738</span>              : // translation.  It is primarily used for messages in thrown exceptions; see</span>
<span id="L739"><span class="lineNum">     739</span>              : // src/functexcept.cc.  We use __N because the more traditional _N is used</span>
<span id="L740"><span class="lineNum">     740</span>              : // for something else under certain OSes (see BADNAMES).</span>
<span id="L741"><span class="lineNum">     741</span>              : #define __N(msgid)     (msgid)</span>
<span id="L742"><span class="lineNum">     742</span>              : </span>
<span id="L743"><span class="lineNum">     743</span>              : // For example, &lt;windows.h&gt; is known to #define min and max as macros...</span>
<span id="L744"><span class="lineNum">     744</span>              : #undef min</span>
<span id="L745"><span class="lineNum">     745</span>              : #undef max</span>
<span id="L746"><span class="lineNum">     746</span>              : </span>
<span id="L747"><span class="lineNum">     747</span>              : // N.B. these _GLIBCXX_USE_C99_XXX macros are defined unconditionally</span>
<span id="L748"><span class="lineNum">     748</span>              : // so they should be tested with #if not with #ifdef.</span>
<span id="L749"><span class="lineNum">     749</span>              : #if __cplusplus &gt;= 201103L</span>
<span id="L750"><span class="lineNum">     750</span>              : # ifndef _GLIBCXX_USE_C99_MATH</span>
<span id="L751"><span class="lineNum">     751</span>              : #  define _GLIBCXX_USE_C99_MATH _GLIBCXX11_USE_C99_MATH</span>
<span id="L752"><span class="lineNum">     752</span>              : # endif</span>
<span id="L753"><span class="lineNum">     753</span>              : # ifndef _GLIBCXX_USE_C99_COMPLEX</span>
<span id="L754"><span class="lineNum">     754</span>              : # define _GLIBCXX_USE_C99_COMPLEX _GLIBCXX11_USE_C99_COMPLEX</span>
<span id="L755"><span class="lineNum">     755</span>              : # endif</span>
<span id="L756"><span class="lineNum">     756</span>              : # ifndef _GLIBCXX_USE_C99_STDIO</span>
<span id="L757"><span class="lineNum">     757</span>              : # define _GLIBCXX_USE_C99_STDIO _GLIBCXX11_USE_C99_STDIO</span>
<span id="L758"><span class="lineNum">     758</span>              : # endif</span>
<span id="L759"><span class="lineNum">     759</span>              : # ifndef _GLIBCXX_USE_C99_STDLIB</span>
<span id="L760"><span class="lineNum">     760</span>              : # define _GLIBCXX_USE_C99_STDLIB _GLIBCXX11_USE_C99_STDLIB</span>
<span id="L761"><span class="lineNum">     761</span>              : # endif</span>
<span id="L762"><span class="lineNum">     762</span>              : # ifndef _GLIBCXX_USE_C99_WCHAR</span>
<span id="L763"><span class="lineNum">     763</span>              : # define _GLIBCXX_USE_C99_WCHAR _GLIBCXX11_USE_C99_WCHAR</span>
<span id="L764"><span class="lineNum">     764</span>              : # endif</span>
<span id="L765"><span class="lineNum">     765</span>              : #else</span>
<span id="L766"><span class="lineNum">     766</span>              : # ifndef _GLIBCXX_USE_C99_MATH</span>
<span id="L767"><span class="lineNum">     767</span>              : #  define _GLIBCXX_USE_C99_MATH _GLIBCXX98_USE_C99_MATH</span>
<span id="L768"><span class="lineNum">     768</span>              : # endif</span>
<span id="L769"><span class="lineNum">     769</span>              : # ifndef _GLIBCXX_USE_C99_COMPLEX</span>
<span id="L770"><span class="lineNum">     770</span>              : # define _GLIBCXX_USE_C99_COMPLEX _GLIBCXX98_USE_C99_COMPLEX</span>
<span id="L771"><span class="lineNum">     771</span>              : # endif</span>
<span id="L772"><span class="lineNum">     772</span>              : # ifndef _GLIBCXX_USE_C99_STDIO</span>
<span id="L773"><span class="lineNum">     773</span>              : # define _GLIBCXX_USE_C99_STDIO _GLIBCXX98_USE_C99_STDIO</span>
<span id="L774"><span class="lineNum">     774</span>              : # endif</span>
<span id="L775"><span class="lineNum">     775</span>              : # ifndef _GLIBCXX_USE_C99_STDLIB</span>
<span id="L776"><span class="lineNum">     776</span>              : # define _GLIBCXX_USE_C99_STDLIB _GLIBCXX98_USE_C99_STDLIB</span>
<span id="L777"><span class="lineNum">     777</span>              : # endif</span>
<span id="L778"><span class="lineNum">     778</span>              : # ifndef _GLIBCXX_USE_C99_WCHAR</span>
<span id="L779"><span class="lineNum">     779</span>              : # define _GLIBCXX_USE_C99_WCHAR _GLIBCXX98_USE_C99_WCHAR</span>
<span id="L780"><span class="lineNum">     780</span>              : # endif</span>
<span id="L781"><span class="lineNum">     781</span>              : #endif</span>
<span id="L782"><span class="lineNum">     782</span>              : </span>
<span id="L783"><span class="lineNum">     783</span>              : // Unless explicitly specified, enable char8_t extensions only if the core</span>
<span id="L784"><span class="lineNum">     784</span>              : // language char8_t feature macro is defined.</span>
<span id="L785"><span class="lineNum">     785</span>              : #ifndef _GLIBCXX_USE_CHAR8_T</span>
<span id="L786"><span class="lineNum">     786</span>              : # ifdef __cpp_char8_t</span>
<span id="L787"><span class="lineNum">     787</span>              : #  define _GLIBCXX_USE_CHAR8_T 1</span>
<span id="L788"><span class="lineNum">     788</span>              : # endif</span>
<span id="L789"><span class="lineNum">     789</span>              : #endif</span>
<span id="L790"><span class="lineNum">     790</span>              : #ifdef _GLIBCXX_USE_CHAR8_T</span>
<span id="L791"><span class="lineNum">     791</span>              : # define __cpp_lib_char8_t 201907L</span>
<span id="L792"><span class="lineNum">     792</span>              : #endif</span>
<span id="L793"><span class="lineNum">     793</span>              : </span>
<span id="L794"><span class="lineNum">     794</span>              : /* Define if __float128 is supported on this host.  */</span>
<span id="L795"><span class="lineNum">     795</span>              : #if defined(__FLOAT128__) || defined(__SIZEOF_FLOAT128__)</span>
<span id="L796"><span class="lineNum">     796</span>              : /* For powerpc64 don't use __float128 when it's the same type as long double. */</span>
<span id="L797"><span class="lineNum">     797</span>              : # if !(defined(_GLIBCXX_LONG_DOUBLE_ALT128_COMPAT) &amp;&amp; defined(__LONG_DOUBLE_IEEE128__))</span>
<span id="L798"><span class="lineNum">     798</span>              : #  define _GLIBCXX_USE_FLOAT128 1</span>
<span id="L799"><span class="lineNum">     799</span>              : # endif</span>
<span id="L800"><span class="lineNum">     800</span>              : #endif</span>
<span id="L801"><span class="lineNum">     801</span>              : </span>
<span id="L802"><span class="lineNum">     802</span>              : // Define if float has the IEEE binary32 format.</span>
<span id="L803"><span class="lineNum">     803</span>              : #if __FLT_MANT_DIG__ == 24 \</span>
<span id="L804"><span class="lineNum">     804</span>              :   &amp;&amp; __FLT_MIN_EXP__ == -125 \</span>
<span id="L805"><span class="lineNum">     805</span>              :   &amp;&amp; __FLT_MAX_EXP__ == 128</span>
<span id="L806"><span class="lineNum">     806</span>              : # define _GLIBCXX_FLOAT_IS_IEEE_BINARY32 1</span>
<span id="L807"><span class="lineNum">     807</span>              : #endif</span>
<span id="L808"><span class="lineNum">     808</span>              : </span>
<span id="L809"><span class="lineNum">     809</span>              : // Define if double has the IEEE binary64 format.</span>
<span id="L810"><span class="lineNum">     810</span>              : #if __DBL_MANT_DIG__ == 53 \</span>
<span id="L811"><span class="lineNum">     811</span>              :   &amp;&amp; __DBL_MIN_EXP__ == -1021 \</span>
<span id="L812"><span class="lineNum">     812</span>              :   &amp;&amp; __DBL_MAX_EXP__ == 1024</span>
<span id="L813"><span class="lineNum">     813</span>              : # define _GLIBCXX_DOUBLE_IS_IEEE_BINARY64 1</span>
<span id="L814"><span class="lineNum">     814</span>              : #endif</span>
<span id="L815"><span class="lineNum">     815</span>              : </span>
<span id="L816"><span class="lineNum">     816</span>              : // Define if long double has the IEEE binary128 format.</span>
<span id="L817"><span class="lineNum">     817</span>              : #if __LDBL_MANT_DIG__ == 113 \</span>
<span id="L818"><span class="lineNum">     818</span>              :   &amp;&amp; __LDBL_MIN_EXP__ == -16381 \</span>
<span id="L819"><span class="lineNum">     819</span>              :   &amp;&amp; __LDBL_MAX_EXP__ == 16384</span>
<span id="L820"><span class="lineNum">     820</span>              : # define _GLIBCXX_LDOUBLE_IS_IEEE_BINARY128 1</span>
<span id="L821"><span class="lineNum">     821</span>              : #endif</span>
<span id="L822"><span class="lineNum">     822</span>              : </span>
<span id="L823"><span class="lineNum">     823</span>              : #ifdef __STDCPP_BFLOAT16_T__</span>
<span id="L824"><span class="lineNum">     824</span>              : namespace __gnu_cxx</span>
<span id="L825"><span class="lineNum">     825</span>              : {</span>
<span id="L826"><span class="lineNum">     826</span>              :   using __bfloat16_t = decltype(0.0bf16);</span>
<span id="L827"><span class="lineNum">     827</span>              : }</span>
<span id="L828"><span class="lineNum">     828</span>              : #endif</span>
<span id="L829"><span class="lineNum">     829</span>              : </span>
<span id="L830"><span class="lineNum">     830</span>              : #ifdef __has_builtin</span>
<span id="L831"><span class="lineNum">     831</span>              : # ifdef __is_identifier</span>
<span id="L832"><span class="lineNum">     832</span>              : // Intel and older Clang require !__is_identifier for some built-ins:</span>
<span id="L833"><span class="lineNum">     833</span>              : #  define _GLIBCXX_HAS_BUILTIN(B) __has_builtin(B) || ! __is_identifier(B)</span>
<span id="L834"><span class="lineNum">     834</span>              : # else</span>
<span id="L835"><span class="lineNum">     835</span>              : #  define _GLIBCXX_HAS_BUILTIN(B) __has_builtin(B)</span>
<span id="L836"><span class="lineNum">     836</span>              : # endif</span>
<span id="L837"><span class="lineNum">     837</span>              : #endif</span>
<span id="L838"><span class="lineNum">     838</span>              : </span>
<span id="L839"><span class="lineNum">     839</span>              : #if _GLIBCXX_HAS_BUILTIN(__has_unique_object_representations)</span>
<span id="L840"><span class="lineNum">     840</span>              : # define _GLIBCXX_HAVE_BUILTIN_HAS_UNIQ_OBJ_REP 1</span>
<span id="L841"><span class="lineNum">     841</span>              : #endif</span>
<span id="L842"><span class="lineNum">     842</span>              : </span>
<span id="L843"><span class="lineNum">     843</span>              : #if _GLIBCXX_HAS_BUILTIN(__is_aggregate)</span>
<span id="L844"><span class="lineNum">     844</span>              : # define _GLIBCXX_HAVE_BUILTIN_IS_AGGREGATE 1</span>
<span id="L845"><span class="lineNum">     845</span>              : #endif</span>
<span id="L846"><span class="lineNum">     846</span>              : </span>
<span id="L847"><span class="lineNum">     847</span>              : #if _GLIBCXX_HAS_BUILTIN(__is_same)</span>
<span id="L848"><span class="lineNum">     848</span>              : #  define _GLIBCXX_HAVE_BUILTIN_IS_SAME 1</span>
<span id="L849"><span class="lineNum">     849</span>              : #endif</span>
<span id="L850"><span class="lineNum">     850</span>              : </span>
<span id="L851"><span class="lineNum">     851</span>              : #if _GLIBCXX_HAS_BUILTIN(__builtin_launder)</span>
<span id="L852"><span class="lineNum">     852</span>              : # define _GLIBCXX_HAVE_BUILTIN_LAUNDER 1</span>
<span id="L853"><span class="lineNum">     853</span>              : #endif</span>
<span id="L854"><span class="lineNum">     854</span>              : </span>
<span id="L855"><span class="lineNum">     855</span>              : #undef _GLIBCXX_HAS_BUILTIN</span>
<span id="L856"><span class="lineNum">     856</span>              : </span>
<span id="L857"><span class="lineNum">     857</span>              : // Mark code that should be ignored by the compiler, but seen by Doxygen.</span>
<span id="L858"><span class="lineNum">     858</span>              : #define _GLIBCXX_DOXYGEN_ONLY(X)</span>
<span id="L859"><span class="lineNum">     859</span>              : </span>
<span id="L860"><span class="lineNum">     860</span>              : // PSTL configuration</span>
<span id="L861"><span class="lineNum">     861</span>              : </span>
<span id="L862"><span class="lineNum">     862</span>              : #if __cplusplus &gt;= 201703L</span>
<span id="L863"><span class="lineNum">     863</span>              : // This header is not installed for freestanding:</span>
<span id="L864"><span class="lineNum">     864</span>              : #if __has_include(&lt;pstl/pstl_config.h&gt;)</span>
<span id="L865"><span class="lineNum">     865</span>              : // Preserved here so we have some idea which version of upstream we've pulled in</span>
<span id="L866"><span class="lineNum">     866</span>              : // #define PSTL_VERSION 9000</span>
<span id="L867"><span class="lineNum">     867</span>              : </span>
<span id="L868"><span class="lineNum">     868</span>              : // For now this defaults to being based on the presence of Thread Building Blocks</span>
<span id="L869"><span class="lineNum">     869</span>              : # ifndef _GLIBCXX_USE_TBB_PAR_BACKEND</span>
<span id="L870"><span class="lineNum">     870</span>              : #  define _GLIBCXX_USE_TBB_PAR_BACKEND __has_include(&lt;tbb/tbb.h&gt;)</span>
<span id="L871"><span class="lineNum">     871</span>              : # endif</span>
<span id="L872"><span class="lineNum">     872</span>              : // This section will need some rework when a new (default) backend type is added</span>
<span id="L873"><span class="lineNum">     873</span>              : # if _GLIBCXX_USE_TBB_PAR_BACKEND</span>
<span id="L874"><span class="lineNum">     874</span>              : #  define _PSTL_PAR_BACKEND_TBB</span>
<span id="L875"><span class="lineNum">     875</span>              : # else</span>
<span id="L876"><span class="lineNum">     876</span>              : #  define _PSTL_PAR_BACKEND_SERIAL</span>
<span id="L877"><span class="lineNum">     877</span>              : # endif</span>
<span id="L878"><span class="lineNum">     878</span>              : </span>
<span id="L879"><span class="lineNum">     879</span>              : # define _PSTL_ASSERT(_Condition) __glibcxx_assert(_Condition)</span>
<span id="L880"><span class="lineNum">     880</span>              : # define _PSTL_ASSERT_MSG(_Condition, _Message) __glibcxx_assert(_Condition)</span>
<span id="L881"><span class="lineNum">     881</span>              : </span>
<span id="L882"><span class="lineNum">     882</span>              : #include &lt;pstl/pstl_config.h&gt;</span>
<span id="L883"><span class="lineNum">     883</span>              : #endif // __has_include</span>
<span id="L884"><span class="lineNum">     884</span>              : #endif // C++17</span>
<span id="L885"><span class="lineNum">     885</span>              : </span>
<span id="L886"><span class="lineNum">     886</span>              : #define _GLIBCXX_TIME_BITS64_ABI_TAG</span>
<span id="L887"><span class="lineNum">     887</span>              : </span>
<span id="L888"><span class="lineNum">     888</span>              : // End of prewritten config; the settings discovered at configure time follow.</span>
<span id="L889"><span class="lineNum">     889</span>              : /* config.h.  Generated from config.h.in by configure.  */</span>
<span id="L890"><span class="lineNum">     890</span>              : /* config.h.in.  Generated from configure.ac by autoheader.  */</span>
<span id="L891"><span class="lineNum">     891</span>              : </span>
<span id="L892"><span class="lineNum">     892</span>              : /* Define to 1 if you have the `acosf' function. */</span>
<span id="L893"><span class="lineNum">     893</span>              : #define _GLIBCXX_HAVE_ACOSF 1</span>
<span id="L894"><span class="lineNum">     894</span>              : </span>
<span id="L895"><span class="lineNum">     895</span>              : /* Define to 1 if you have the `acosl' function. */</span>
<span id="L896"><span class="lineNum">     896</span>              : #define _GLIBCXX_HAVE_ACOSL 1</span>
<span id="L897"><span class="lineNum">     897</span>              : </span>
<span id="L898"><span class="lineNum">     898</span>              : /* Define to 1 if you have the `aligned_alloc' function. */</span>
<span id="L899"><span class="lineNum">     899</span>              : #define _GLIBCXX_HAVE_ALIGNED_ALLOC 1</span>
<span id="L900"><span class="lineNum">     900</span>              : </span>
<span id="L901"><span class="lineNum">     901</span>              : /* Define if arc4random is available in &lt;stdlib.h&gt;. */</span>
<span id="L902"><span class="lineNum">     902</span>              : #define _GLIBCXX_HAVE_ARC4RANDOM 1</span>
<span id="L903"><span class="lineNum">     903</span>              : </span>
<span id="L904"><span class="lineNum">     904</span>              : /* Define to 1 if you have the &lt;arpa/inet.h&gt; header file. */</span>
<span id="L905"><span class="lineNum">     905</span>              : #define _GLIBCXX_HAVE_ARPA_INET_H 1</span>
<span id="L906"><span class="lineNum">     906</span>              : </span>
<span id="L907"><span class="lineNum">     907</span>              : /* Define to 1 if you have the `asinf' function. */</span>
<span id="L908"><span class="lineNum">     908</span>              : #define _GLIBCXX_HAVE_ASINF 1</span>
<span id="L909"><span class="lineNum">     909</span>              : </span>
<span id="L910"><span class="lineNum">     910</span>              : /* Define to 1 if you have the `asinl' function. */</span>
<span id="L911"><span class="lineNum">     911</span>              : #define _GLIBCXX_HAVE_ASINL 1</span>
<span id="L912"><span class="lineNum">     912</span>              : </span>
<span id="L913"><span class="lineNum">     913</span>              : /* Define to 1 if the target assembler supports .symver directive. */</span>
<span id="L914"><span class="lineNum">     914</span>              : #define _GLIBCXX_HAVE_AS_SYMVER_DIRECTIVE 1</span>
<span id="L915"><span class="lineNum">     915</span>              : </span>
<span id="L916"><span class="lineNum">     916</span>              : /* Define to 1 if you have the `atan2f' function. */</span>
<span id="L917"><span class="lineNum">     917</span>              : #define _GLIBCXX_HAVE_ATAN2F 1</span>
<span id="L918"><span class="lineNum">     918</span>              : </span>
<span id="L919"><span class="lineNum">     919</span>              : /* Define to 1 if you have the `atan2l' function. */</span>
<span id="L920"><span class="lineNum">     920</span>              : #define _GLIBCXX_HAVE_ATAN2L 1</span>
<span id="L921"><span class="lineNum">     921</span>              : </span>
<span id="L922"><span class="lineNum">     922</span>              : /* Define to 1 if you have the `atanf' function. */</span>
<span id="L923"><span class="lineNum">     923</span>              : #define _GLIBCXX_HAVE_ATANF 1</span>
<span id="L924"><span class="lineNum">     924</span>              : </span>
<span id="L925"><span class="lineNum">     925</span>              : /* Define to 1 if you have the `atanl' function. */</span>
<span id="L926"><span class="lineNum">     926</span>              : #define _GLIBCXX_HAVE_ATANL 1</span>
<span id="L927"><span class="lineNum">     927</span>              : </span>
<span id="L928"><span class="lineNum">     928</span>              : /* Defined if shared_ptr reference counting should use atomic operations. */</span>
<span id="L929"><span class="lineNum">     929</span>              : #define _GLIBCXX_HAVE_ATOMIC_LOCK_POLICY 1</span>
<span id="L930"><span class="lineNum">     930</span>              : </span>
<span id="L931"><span class="lineNum">     931</span>              : /* Define to 1 if you have the `at_quick_exit' function. */</span>
<span id="L932"><span class="lineNum">     932</span>              : #define _GLIBCXX_HAVE_AT_QUICK_EXIT 1</span>
<span id="L933"><span class="lineNum">     933</span>              : </span>
<span id="L934"><span class="lineNum">     934</span>              : /* Define to 1 if the target assembler supports thread-local storage. */</span>
<span id="L935"><span class="lineNum">     935</span>              : /* #undef _GLIBCXX_HAVE_CC_TLS */</span>
<span id="L936"><span class="lineNum">     936</span>              : </span>
<span id="L937"><span class="lineNum">     937</span>              : /* Define to 1 if you have the `ceilf' function. */</span>
<span id="L938"><span class="lineNum">     938</span>              : #define _GLIBCXX_HAVE_CEILF 1</span>
<span id="L939"><span class="lineNum">     939</span>              : </span>
<span id="L940"><span class="lineNum">     940</span>              : /* Define to 1 if you have the `ceill' function. */</span>
<span id="L941"><span class="lineNum">     941</span>              : #define _GLIBCXX_HAVE_CEILL 1</span>
<span id="L942"><span class="lineNum">     942</span>              : </span>
<span id="L943"><span class="lineNum">     943</span>              : /* Define to 1 if you have the &lt;complex.h&gt; header file. */</span>
<span id="L944"><span class="lineNum">     944</span>              : #define _GLIBCXX_HAVE_COMPLEX_H 1</span>
<span id="L945"><span class="lineNum">     945</span>              : </span>
<span id="L946"><span class="lineNum">     946</span>              : /* Define to 1 if you have the `cosf' function. */</span>
<span id="L947"><span class="lineNum">     947</span>              : #define _GLIBCXX_HAVE_COSF 1</span>
<span id="L948"><span class="lineNum">     948</span>              : </span>
<span id="L949"><span class="lineNum">     949</span>              : /* Define to 1 if you have the `coshf' function. */</span>
<span id="L950"><span class="lineNum">     950</span>              : #define _GLIBCXX_HAVE_COSHF 1</span>
<span id="L951"><span class="lineNum">     951</span>              : </span>
<span id="L952"><span class="lineNum">     952</span>              : /* Define to 1 if you have the `coshl' function. */</span>
<span id="L953"><span class="lineNum">     953</span>              : #define _GLIBCXX_HAVE_COSHL 1</span>
<span id="L954"><span class="lineNum">     954</span>              : </span>
<span id="L955"><span class="lineNum">     955</span>              : /* Define to 1 if you have the `cosl' function. */</span>
<span id="L956"><span class="lineNum">     956</span>              : #define _GLIBCXX_HAVE_COSL 1</span>
<span id="L957"><span class="lineNum">     957</span>              : </span>
<span id="L958"><span class="lineNum">     958</span>              : /* Define to 1 if you have the declaration of `strnlen', and to 0 if you</span>
<span id="L959"><span class="lineNum">     959</span>              :    don't. */</span>
<span id="L960"><span class="lineNum">     960</span>              : #define _GLIBCXX_HAVE_DECL_STRNLEN 1</span>
<span id="L961"><span class="lineNum">     961</span>              : </span>
<span id="L962"><span class="lineNum">     962</span>              : /* Define to 1 if you have the &lt;dirent.h&gt; header file. */</span>
<span id="L963"><span class="lineNum">     963</span>              : #define _GLIBCXX_HAVE_DIRENT_H 1</span>
<span id="L964"><span class="lineNum">     964</span>              : </span>
<span id="L965"><span class="lineNum">     965</span>              : /* Define if dirfd is available in &lt;dirent.h&gt;. */</span>
<span id="L966"><span class="lineNum">     966</span>              : #define _GLIBCXX_HAVE_DIRFD 1</span>
<span id="L967"><span class="lineNum">     967</span>              : </span>
<span id="L968"><span class="lineNum">     968</span>              : /* Define to 1 if you have the &lt;dlfcn.h&gt; header file. */</span>
<span id="L969"><span class="lineNum">     969</span>              : #define _GLIBCXX_HAVE_DLFCN_H 1</span>
<span id="L970"><span class="lineNum">     970</span>              : </span>
<span id="L971"><span class="lineNum">     971</span>              : /* Define to 1 if you have the &lt;endian.h&gt; header file. */</span>
<span id="L972"><span class="lineNum">     972</span>              : #define _GLIBCXX_HAVE_ENDIAN_H 1</span>
<span id="L973"><span class="lineNum">     973</span>              : </span>
<span id="L974"><span class="lineNum">     974</span>              : /* Define to 1 if GCC 4.6 supported std::exception_ptr for the target */</span>
<span id="L975"><span class="lineNum">     975</span>              : #define _GLIBCXX_HAVE_EXCEPTION_PTR_SINCE_GCC46 1</span>
<span id="L976"><span class="lineNum">     976</span>              : </span>
<span id="L977"><span class="lineNum">     977</span>              : /* Define to 1 if you have the &lt;execinfo.h&gt; header file. */</span>
<span id="L978"><span class="lineNum">     978</span>              : #define _GLIBCXX_HAVE_EXECINFO_H 1</span>
<span id="L979"><span class="lineNum">     979</span>              : </span>
<span id="L980"><span class="lineNum">     980</span>              : /* Define to 1 if you have the `expf' function. */</span>
<span id="L981"><span class="lineNum">     981</span>              : #define _GLIBCXX_HAVE_EXPF 1</span>
<span id="L982"><span class="lineNum">     982</span>              : </span>
<span id="L983"><span class="lineNum">     983</span>              : /* Define to 1 if you have the `expl' function. */</span>
<span id="L984"><span class="lineNum">     984</span>              : #define _GLIBCXX_HAVE_EXPL 1</span>
<span id="L985"><span class="lineNum">     985</span>              : </span>
<span id="L986"><span class="lineNum">     986</span>              : /* Define to 1 if you have the `fabsf' function. */</span>
<span id="L987"><span class="lineNum">     987</span>              : #define _GLIBCXX_HAVE_FABSF 1</span>
<span id="L988"><span class="lineNum">     988</span>              : </span>
<span id="L989"><span class="lineNum">     989</span>              : /* Define to 1 if you have the `fabsl' function. */</span>
<span id="L990"><span class="lineNum">     990</span>              : #define _GLIBCXX_HAVE_FABSL 1</span>
<span id="L991"><span class="lineNum">     991</span>              : </span>
<span id="L992"><span class="lineNum">     992</span>              : /* Define to 1 if you have the &lt;fcntl.h&gt; header file. */</span>
<span id="L993"><span class="lineNum">     993</span>              : #define _GLIBCXX_HAVE_FCNTL_H 1</span>
<span id="L994"><span class="lineNum">     994</span>              : </span>
<span id="L995"><span class="lineNum">     995</span>              : /* Define if fdopendir is available in &lt;dirent.h&gt;. */</span>
<span id="L996"><span class="lineNum">     996</span>              : #define _GLIBCXX_HAVE_FDOPENDIR 1</span>
<span id="L997"><span class="lineNum">     997</span>              : </span>
<span id="L998"><span class="lineNum">     998</span>              : /* Define to 1 if you have the &lt;fenv.h&gt; header file. */</span>
<span id="L999"><span class="lineNum">     999</span>              : #define _GLIBCXX_HAVE_FENV_H 1</span>
<span id="L1000"><span class="lineNum">    1000</span>              : </span>
<span id="L1001"><span class="lineNum">    1001</span>              : /* Define to 1 if you have the `finite' function. */</span>
<span id="L1002"><span class="lineNum">    1002</span>              : #define _GLIBCXX_HAVE_FINITE 1</span>
<span id="L1003"><span class="lineNum">    1003</span>              : </span>
<span id="L1004"><span class="lineNum">    1004</span>              : /* Define to 1 if you have the `finitef' function. */</span>
<span id="L1005"><span class="lineNum">    1005</span>              : #define _GLIBCXX_HAVE_FINITEF 1</span>
<span id="L1006"><span class="lineNum">    1006</span>              : </span>
<span id="L1007"><span class="lineNum">    1007</span>              : /* Define to 1 if you have the `finitel' function. */</span>
<span id="L1008"><span class="lineNum">    1008</span>              : #define _GLIBCXX_HAVE_FINITEL 1</span>
<span id="L1009"><span class="lineNum">    1009</span>              : </span>
<span id="L1010"><span class="lineNum">    1010</span>              : /* Define to 1 if you have the &lt;float.h&gt; header file. */</span>
<span id="L1011"><span class="lineNum">    1011</span>              : #define _GLIBCXX_HAVE_FLOAT_H 1</span>
<span id="L1012"><span class="lineNum">    1012</span>              : </span>
<span id="L1013"><span class="lineNum">    1013</span>              : /* Define to 1 if you have the `floorf' function. */</span>
<span id="L1014"><span class="lineNum">    1014</span>              : #define _GLIBCXX_HAVE_FLOORF 1</span>
<span id="L1015"><span class="lineNum">    1015</span>              : </span>
<span id="L1016"><span class="lineNum">    1016</span>              : /* Define to 1 if you have the `floorl' function. */</span>
<span id="L1017"><span class="lineNum">    1017</span>              : #define _GLIBCXX_HAVE_FLOORL 1</span>
<span id="L1018"><span class="lineNum">    1018</span>              : </span>
<span id="L1019"><span class="lineNum">    1019</span>              : /* Define to 1 if you have the `fmodf' function. */</span>
<span id="L1020"><span class="lineNum">    1020</span>              : #define _GLIBCXX_HAVE_FMODF 1</span>
<span id="L1021"><span class="lineNum">    1021</span>              : </span>
<span id="L1022"><span class="lineNum">    1022</span>              : /* Define to 1 if you have the `fmodl' function. */</span>
<span id="L1023"><span class="lineNum">    1023</span>              : #define _GLIBCXX_HAVE_FMODL 1</span>
<span id="L1024"><span class="lineNum">    1024</span>              : </span>
<span id="L1025"><span class="lineNum">    1025</span>              : /* Define to 1 if you have the `fpclass' function. */</span>
<span id="L1026"><span class="lineNum">    1026</span>              : /* #undef _GLIBCXX_HAVE_FPCLASS */</span>
<span id="L1027"><span class="lineNum">    1027</span>              : </span>
<span id="L1028"><span class="lineNum">    1028</span>              : /* Define to 1 if you have the &lt;fp.h&gt; header file. */</span>
<span id="L1029"><span class="lineNum">    1029</span>              : /* #undef _GLIBCXX_HAVE_FP_H */</span>
<span id="L1030"><span class="lineNum">    1030</span>              : </span>
<span id="L1031"><span class="lineNum">    1031</span>              : /* Define to 1 if you have the `frexpf' function. */</span>
<span id="L1032"><span class="lineNum">    1032</span>              : #define _GLIBCXX_HAVE_FREXPF 1</span>
<span id="L1033"><span class="lineNum">    1033</span>              : </span>
<span id="L1034"><span class="lineNum">    1034</span>              : /* Define to 1 if you have the `frexpl' function. */</span>
<span id="L1035"><span class="lineNum">    1035</span>              : #define _GLIBCXX_HAVE_FREXPL 1</span>
<span id="L1036"><span class="lineNum">    1036</span>              : </span>
<span id="L1037"><span class="lineNum">    1037</span>              : /* Define if getentropy is available in &lt;unistd.h&gt;. */</span>
<span id="L1038"><span class="lineNum">    1038</span>              : #define _GLIBCXX_HAVE_GETENTROPY 1</span>
<span id="L1039"><span class="lineNum">    1039</span>              : </span>
<span id="L1040"><span class="lineNum">    1040</span>              : /* Define if _Unwind_GetIPInfo is available. */</span>
<span id="L1041"><span class="lineNum">    1041</span>              : #define _GLIBCXX_HAVE_GETIPINFO 1</span>
<span id="L1042"><span class="lineNum">    1042</span>              : </span>
<span id="L1043"><span class="lineNum">    1043</span>              : /* Define if gets is available in &lt;stdio.h&gt; before C++14. */</span>
<span id="L1044"><span class="lineNum">    1044</span>              : #define _GLIBCXX_HAVE_GETS 1</span>
<span id="L1045"><span class="lineNum">    1045</span>              : </span>
<span id="L1046"><span class="lineNum">    1046</span>              : /* Define to 1 if you have the `hypot' function. */</span>
<span id="L1047"><span class="lineNum">    1047</span>              : #define _GLIBCXX_HAVE_HYPOT 1</span>
<span id="L1048"><span class="lineNum">    1048</span>              : </span>
<span id="L1049"><span class="lineNum">    1049</span>              : /* Define to 1 if you have the `hypotf' function. */</span>
<span id="L1050"><span class="lineNum">    1050</span>              : #define _GLIBCXX_HAVE_HYPOTF 1</span>
<span id="L1051"><span class="lineNum">    1051</span>              : </span>
<span id="L1052"><span class="lineNum">    1052</span>              : /* Define to 1 if you have the `hypotl' function. */</span>
<span id="L1053"><span class="lineNum">    1053</span>              : #define _GLIBCXX_HAVE_HYPOTL 1</span>
<span id="L1054"><span class="lineNum">    1054</span>              : </span>
<span id="L1055"><span class="lineNum">    1055</span>              : /* Define if you have the iconv() function. */</span>
<span id="L1056"><span class="lineNum">    1056</span>              : #define _GLIBCXX_HAVE_ICONV 1</span>
<span id="L1057"><span class="lineNum">    1057</span>              : </span>
<span id="L1058"><span class="lineNum">    1058</span>              : /* Define to 1 if you have the &lt;ieeefp.h&gt; header file. */</span>
<span id="L1059"><span class="lineNum">    1059</span>              : /* #undef _GLIBCXX_HAVE_IEEEFP_H */</span>
<span id="L1060"><span class="lineNum">    1060</span>              : </span>
<span id="L1061"><span class="lineNum">    1061</span>              : /* Define to 1 if you have the &lt;inttypes.h&gt; header file. */</span>
<span id="L1062"><span class="lineNum">    1062</span>              : #define _GLIBCXX_HAVE_INTTYPES_H 1</span>
<span id="L1063"><span class="lineNum">    1063</span>              : </span>
<span id="L1064"><span class="lineNum">    1064</span>              : /* Define to 1 if you have the `isinf' function. */</span>
<span id="L1065"><span class="lineNum">    1065</span>              : /* #undef _GLIBCXX_HAVE_ISINF */</span>
<span id="L1066"><span class="lineNum">    1066</span>              : </span>
<span id="L1067"><span class="lineNum">    1067</span>              : /* Define to 1 if you have the `isinff' function. */</span>
<span id="L1068"><span class="lineNum">    1068</span>              : #define _GLIBCXX_HAVE_ISINFF 1</span>
<span id="L1069"><span class="lineNum">    1069</span>              : </span>
<span id="L1070"><span class="lineNum">    1070</span>              : /* Define to 1 if you have the `isinfl' function. */</span>
<span id="L1071"><span class="lineNum">    1071</span>              : #define _GLIBCXX_HAVE_ISINFL 1</span>
<span id="L1072"><span class="lineNum">    1072</span>              : </span>
<span id="L1073"><span class="lineNum">    1073</span>              : /* Define to 1 if you have the `isnan' function. */</span>
<span id="L1074"><span class="lineNum">    1074</span>              : /* #undef _GLIBCXX_HAVE_ISNAN */</span>
<span id="L1075"><span class="lineNum">    1075</span>              : </span>
<span id="L1076"><span class="lineNum">    1076</span>              : /* Define to 1 if you have the `isnanf' function. */</span>
<span id="L1077"><span class="lineNum">    1077</span>              : #define _GLIBCXX_HAVE_ISNANF 1</span>
<span id="L1078"><span class="lineNum">    1078</span>              : </span>
<span id="L1079"><span class="lineNum">    1079</span>              : /* Define to 1 if you have the `isnanl' function. */</span>
<span id="L1080"><span class="lineNum">    1080</span>              : #define _GLIBCXX_HAVE_ISNANL 1</span>
<span id="L1081"><span class="lineNum">    1081</span>              : </span>
<span id="L1082"><span class="lineNum">    1082</span>              : /* Defined if iswblank exists. */</span>
<span id="L1083"><span class="lineNum">    1083</span>              : #define _GLIBCXX_HAVE_ISWBLANK 1</span>
<span id="L1084"><span class="lineNum">    1084</span>              : </span>
<span id="L1085"><span class="lineNum">    1085</span>              : /* Define if LC_MESSAGES is available in &lt;locale.h&gt;. */</span>
<span id="L1086"><span class="lineNum">    1086</span>              : #define _GLIBCXX_HAVE_LC_MESSAGES 1</span>
<span id="L1087"><span class="lineNum">    1087</span>              : </span>
<span id="L1088"><span class="lineNum">    1088</span>              : /* Define to 1 if you have the `ldexpf' function. */</span>
<span id="L1089"><span class="lineNum">    1089</span>              : #define _GLIBCXX_HAVE_LDEXPF 1</span>
<span id="L1090"><span class="lineNum">    1090</span>              : </span>
<span id="L1091"><span class="lineNum">    1091</span>              : /* Define to 1 if you have the `ldexpl' function. */</span>
<span id="L1092"><span class="lineNum">    1092</span>              : #define _GLIBCXX_HAVE_LDEXPL 1</span>
<span id="L1093"><span class="lineNum">    1093</span>              : </span>
<span id="L1094"><span class="lineNum">    1094</span>              : /* Define to 1 if you have the &lt;libintl.h&gt; header file. */</span>
<span id="L1095"><span class="lineNum">    1095</span>              : #define _GLIBCXX_HAVE_LIBINTL_H 1</span>
<span id="L1096"><span class="lineNum">    1096</span>              : </span>
<span id="L1097"><span class="lineNum">    1097</span>              : /* Only used in build directory testsuite_hooks.h. */</span>
<span id="L1098"><span class="lineNum">    1098</span>              : #define _GLIBCXX_HAVE_LIMIT_AS 1</span>
<span id="L1099"><span class="lineNum">    1099</span>              : </span>
<span id="L1100"><span class="lineNum">    1100</span>              : /* Only used in build directory testsuite_hooks.h. */</span>
<span id="L1101"><span class="lineNum">    1101</span>              : #define _GLIBCXX_HAVE_LIMIT_DATA 1</span>
<span id="L1102"><span class="lineNum">    1102</span>              : </span>
<span id="L1103"><span class="lineNum">    1103</span>              : /* Only used in build directory testsuite_hooks.h. */</span>
<span id="L1104"><span class="lineNum">    1104</span>              : #define _GLIBCXX_HAVE_LIMIT_FSIZE 1</span>
<span id="L1105"><span class="lineNum">    1105</span>              : </span>
<span id="L1106"><span class="lineNum">    1106</span>              : /* Only used in build directory testsuite_hooks.h. */</span>
<span id="L1107"><span class="lineNum">    1107</span>              : #define _GLIBCXX_HAVE_LIMIT_RSS 1</span>
<span id="L1108"><span class="lineNum">    1108</span>              : </span>
<span id="L1109"><span class="lineNum">    1109</span>              : /* Only used in build directory testsuite_hooks.h. */</span>
<span id="L1110"><span class="lineNum">    1110</span>              : #define _GLIBCXX_HAVE_LIMIT_VMEM 0</span>
<span id="L1111"><span class="lineNum">    1111</span>              : </span>
<span id="L1112"><span class="lineNum">    1112</span>              : /* Define if link is available in &lt;unistd.h&gt;. */</span>
<span id="L1113"><span class="lineNum">    1113</span>              : #define _GLIBCXX_HAVE_LINK 1</span>
<span id="L1114"><span class="lineNum">    1114</span>              : </span>
<span id="L1115"><span class="lineNum">    1115</span>              : /* Define to 1 if you have the &lt;link.h&gt; header file. */</span>
<span id="L1116"><span class="lineNum">    1116</span>              : #define _GLIBCXX_HAVE_LINK_H 1</span>
<span id="L1117"><span class="lineNum">    1117</span>              : </span>
<span id="L1118"><span class="lineNum">    1118</span>              : /* Define if futex syscall is available. */</span>
<span id="L1119"><span class="lineNum">    1119</span>              : #define _GLIBCXX_HAVE_LINUX_FUTEX 1</span>
<span id="L1120"><span class="lineNum">    1120</span>              : </span>
<span id="L1121"><span class="lineNum">    1121</span>              : /* Define to 1 if you have the &lt;linux/random.h&gt; header file. */</span>
<span id="L1122"><span class="lineNum">    1122</span>              : #define _GLIBCXX_HAVE_LINUX_RANDOM_H 1</span>
<span id="L1123"><span class="lineNum">    1123</span>              : </span>
<span id="L1124"><span class="lineNum">    1124</span>              : /* Define to 1 if you have the &lt;linux/types.h&gt; header file. */</span>
<span id="L1125"><span class="lineNum">    1125</span>              : #define _GLIBCXX_HAVE_LINUX_TYPES_H 1</span>
<span id="L1126"><span class="lineNum">    1126</span>              : </span>
<span id="L1127"><span class="lineNum">    1127</span>              : /* Define to 1 if you have the &lt;locale.h&gt; header file. */</span>
<span id="L1128"><span class="lineNum">    1128</span>              : #define _GLIBCXX_HAVE_LOCALE_H 1</span>
<span id="L1129"><span class="lineNum">    1129</span>              : </span>
<span id="L1130"><span class="lineNum">    1130</span>              : /* Define to 1 if you have the `log10f' function. */</span>
<span id="L1131"><span class="lineNum">    1131</span>              : #define _GLIBCXX_HAVE_LOG10F 1</span>
<span id="L1132"><span class="lineNum">    1132</span>              : </span>
<span id="L1133"><span class="lineNum">    1133</span>              : /* Define to 1 if you have the `log10l' function. */</span>
<span id="L1134"><span class="lineNum">    1134</span>              : #define _GLIBCXX_HAVE_LOG10L 1</span>
<span id="L1135"><span class="lineNum">    1135</span>              : </span>
<span id="L1136"><span class="lineNum">    1136</span>              : /* Define to 1 if you have the `logf' function. */</span>
<span id="L1137"><span class="lineNum">    1137</span>              : #define _GLIBCXX_HAVE_LOGF 1</span>
<span id="L1138"><span class="lineNum">    1138</span>              : </span>
<span id="L1139"><span class="lineNum">    1139</span>              : /* Define to 1 if you have the `logl' function. */</span>
<span id="L1140"><span class="lineNum">    1140</span>              : #define _GLIBCXX_HAVE_LOGL 1</span>
<span id="L1141"><span class="lineNum">    1141</span>              : </span>
<span id="L1142"><span class="lineNum">    1142</span>              : /* Define to 1 if you have the &lt;machine/endian.h&gt; header file. */</span>
<span id="L1143"><span class="lineNum">    1143</span>              : /* #undef _GLIBCXX_HAVE_MACHINE_ENDIAN_H */</span>
<span id="L1144"><span class="lineNum">    1144</span>              : </span>
<span id="L1145"><span class="lineNum">    1145</span>              : /* Define to 1 if you have the &lt;machine/param.h&gt; header file. */</span>
<span id="L1146"><span class="lineNum">    1146</span>              : /* #undef _GLIBCXX_HAVE_MACHINE_PARAM_H */</span>
<span id="L1147"><span class="lineNum">    1147</span>              : </span>
<span id="L1148"><span class="lineNum">    1148</span>              : /* Define if mbstate_t exists in wchar.h. */</span>
<span id="L1149"><span class="lineNum">    1149</span>              : #define _GLIBCXX_HAVE_MBSTATE_T 1</span>
<span id="L1150"><span class="lineNum">    1150</span>              : </span>
<span id="L1151"><span class="lineNum">    1151</span>              : /* Define to 1 if you have the `memalign' function. */</span>
<span id="L1152"><span class="lineNum">    1152</span>              : #define _GLIBCXX_HAVE_MEMALIGN 1</span>
<span id="L1153"><span class="lineNum">    1153</span>              : </span>
<span id="L1154"><span class="lineNum">    1154</span>              : /* Define to 1 if you have the &lt;memory.h&gt; header file. */</span>
<span id="L1155"><span class="lineNum">    1155</span>              : #define _GLIBCXX_HAVE_MEMORY_H 1</span>
<span id="L1156"><span class="lineNum">    1156</span>              : </span>
<span id="L1157"><span class="lineNum">    1157</span>              : /* Define to 1 if you have the `modf' function. */</span>
<span id="L1158"><span class="lineNum">    1158</span>              : #define _GLIBCXX_HAVE_MODF 1</span>
<span id="L1159"><span class="lineNum">    1159</span>              : </span>
<span id="L1160"><span class="lineNum">    1160</span>              : /* Define to 1 if you have the `modff' function. */</span>
<span id="L1161"><span class="lineNum">    1161</span>              : #define _GLIBCXX_HAVE_MODFF 1</span>
<span id="L1162"><span class="lineNum">    1162</span>              : </span>
<span id="L1163"><span class="lineNum">    1163</span>              : /* Define to 1 if you have the `modfl' function. */</span>
<span id="L1164"><span class="lineNum">    1164</span>              : #define _GLIBCXX_HAVE_MODFL 1</span>
<span id="L1165"><span class="lineNum">    1165</span>              : </span>
<span id="L1166"><span class="lineNum">    1166</span>              : /* Define to 1 if you have the &lt;nan.h&gt; header file. */</span>
<span id="L1167"><span class="lineNum">    1167</span>              : /* #undef _GLIBCXX_HAVE_NAN_H */</span>
<span id="L1168"><span class="lineNum">    1168</span>              : </span>
<span id="L1169"><span class="lineNum">    1169</span>              : /* Define to 1 if you have the &lt;netdb.h&gt; header file. */</span>
<span id="L1170"><span class="lineNum">    1170</span>              : #define _GLIBCXX_HAVE_NETDB_H 1</span>
<span id="L1171"><span class="lineNum">    1171</span>              : </span>
<span id="L1172"><span class="lineNum">    1172</span>              : /* Define to 1 if you have the &lt;netinet/in.h&gt; header file. */</span>
<span id="L1173"><span class="lineNum">    1173</span>              : #define _GLIBCXX_HAVE_NETINET_IN_H 1</span>
<span id="L1174"><span class="lineNum">    1174</span>              : </span>
<span id="L1175"><span class="lineNum">    1175</span>              : /* Define to 1 if you have the &lt;netinet/tcp.h&gt; header file. */</span>
<span id="L1176"><span class="lineNum">    1176</span>              : #define _GLIBCXX_HAVE_NETINET_TCP_H 1</span>
<span id="L1177"><span class="lineNum">    1177</span>              : </span>
<span id="L1178"><span class="lineNum">    1178</span>              : /* Define if &lt;math.h&gt; defines obsolete isinf function. */</span>
<span id="L1179"><span class="lineNum">    1179</span>              : /* #undef _GLIBCXX_HAVE_OBSOLETE_ISINF */</span>
<span id="L1180"><span class="lineNum">    1180</span>              : </span>
<span id="L1181"><span class="lineNum">    1181</span>              : /* Define if &lt;math.h&gt; defines obsolete isnan function. */</span>
<span id="L1182"><span class="lineNum">    1182</span>              : /* #undef _GLIBCXX_HAVE_OBSOLETE_ISNAN */</span>
<span id="L1183"><span class="lineNum">    1183</span>              : </span>
<span id="L1184"><span class="lineNum">    1184</span>              : /* Define if openat is available in &lt;fcntl.h&gt;. */</span>
<span id="L1185"><span class="lineNum">    1185</span>              : #define _GLIBCXX_HAVE_OPENAT 1</span>
<span id="L1186"><span class="lineNum">    1186</span>              : </span>
<span id="L1187"><span class="lineNum">    1187</span>              : /* Define if poll is available in &lt;poll.h&gt;. */</span>
<span id="L1188"><span class="lineNum">    1188</span>              : #define _GLIBCXX_HAVE_POLL 1</span>
<span id="L1189"><span class="lineNum">    1189</span>              : </span>
<span id="L1190"><span class="lineNum">    1190</span>              : /* Define to 1 if you have the &lt;poll.h&gt; header file. */</span>
<span id="L1191"><span class="lineNum">    1191</span>              : #define _GLIBCXX_HAVE_POLL_H 1</span>
<span id="L1192"><span class="lineNum">    1192</span>              : </span>
<span id="L1193"><span class="lineNum">    1193</span>              : /* Define to 1 if you have the `posix_memalign' function. */</span>
<span id="L1194"><span class="lineNum">    1194</span>              : #define _GLIBCXX_HAVE_POSIX_MEMALIGN 1</span>
<span id="L1195"><span class="lineNum">    1195</span>              : </span>
<span id="L1196"><span class="lineNum">    1196</span>              : /* Define to 1 if POSIX Semaphores with sem_timedwait are available in</span>
<span id="L1197"><span class="lineNum">    1197</span>              :    &lt;semaphore.h&gt;. */</span>
<span id="L1198"><span class="lineNum">    1198</span>              : #define _GLIBCXX_HAVE_POSIX_SEMAPHORE 1</span>
<span id="L1199"><span class="lineNum">    1199</span>              : </span>
<span id="L1200"><span class="lineNum">    1200</span>              : /* Define to 1 if you have the `powf' function. */</span>
<span id="L1201"><span class="lineNum">    1201</span>              : #define _GLIBCXX_HAVE_POWF 1</span>
<span id="L1202"><span class="lineNum">    1202</span>              : </span>
<span id="L1203"><span class="lineNum">    1203</span>              : /* Define to 1 if you have the `powl' function. */</span>
<span id="L1204"><span class="lineNum">    1204</span>              : #define _GLIBCXX_HAVE_POWL 1</span>
<span id="L1205"><span class="lineNum">    1205</span>              : </span>
<span id="L1206"><span class="lineNum">    1206</span>              : /* Define to 1 if you have the `qfpclass' function. */</span>
<span id="L1207"><span class="lineNum">    1207</span>              : /* #undef _GLIBCXX_HAVE_QFPCLASS */</span>
<span id="L1208"><span class="lineNum">    1208</span>              : </span>
<span id="L1209"><span class="lineNum">    1209</span>              : /* Define to 1 if you have the `quick_exit' function. */</span>
<span id="L1210"><span class="lineNum">    1210</span>              : #define _GLIBCXX_HAVE_QUICK_EXIT 1</span>
<span id="L1211"><span class="lineNum">    1211</span>              : </span>
<span id="L1212"><span class="lineNum">    1212</span>              : /* Define if readlink is available in &lt;unistd.h&gt;. */</span>
<span id="L1213"><span class="lineNum">    1213</span>              : #define _GLIBCXX_HAVE_READLINK 1</span>
<span id="L1214"><span class="lineNum">    1214</span>              : </span>
<span id="L1215"><span class="lineNum">    1215</span>              : /* Define to 1 if you have the `secure_getenv' function. */</span>
<span id="L1216"><span class="lineNum">    1216</span>              : #define _GLIBCXX_HAVE_SECURE_GETENV 1</span>
<span id="L1217"><span class="lineNum">    1217</span>              : </span>
<span id="L1218"><span class="lineNum">    1218</span>              : /* Define to 1 if you have the `setenv' function. */</span>
<span id="L1219"><span class="lineNum">    1219</span>              : #define _GLIBCXX_HAVE_SETENV 1</span>
<span id="L1220"><span class="lineNum">    1220</span>              : </span>
<span id="L1221"><span class="lineNum">    1221</span>              : /* Define to 1 if you have the `sincos' function. */</span>
<span id="L1222"><span class="lineNum">    1222</span>              : #define _GLIBCXX_HAVE_SINCOS 1</span>
<span id="L1223"><span class="lineNum">    1223</span>              : </span>
<span id="L1224"><span class="lineNum">    1224</span>              : /* Define to 1 if you have the `sincosf' function. */</span>
<span id="L1225"><span class="lineNum">    1225</span>              : #define _GLIBCXX_HAVE_SINCOSF 1</span>
<span id="L1226"><span class="lineNum">    1226</span>              : </span>
<span id="L1227"><span class="lineNum">    1227</span>              : /* Define to 1 if you have the `sincosl' function. */</span>
<span id="L1228"><span class="lineNum">    1228</span>              : #define _GLIBCXX_HAVE_SINCOSL 1</span>
<span id="L1229"><span class="lineNum">    1229</span>              : </span>
<span id="L1230"><span class="lineNum">    1230</span>              : /* Define to 1 if you have the `sinf' function. */</span>
<span id="L1231"><span class="lineNum">    1231</span>              : #define _GLIBCXX_HAVE_SINF 1</span>
<span id="L1232"><span class="lineNum">    1232</span>              : </span>
<span id="L1233"><span class="lineNum">    1233</span>              : /* Define to 1 if you have the `sinhf' function. */</span>
<span id="L1234"><span class="lineNum">    1234</span>              : #define _GLIBCXX_HAVE_SINHF 1</span>
<span id="L1235"><span class="lineNum">    1235</span>              : </span>
<span id="L1236"><span class="lineNum">    1236</span>              : /* Define to 1 if you have the `sinhl' function. */</span>
<span id="L1237"><span class="lineNum">    1237</span>              : #define _GLIBCXX_HAVE_SINHL 1</span>
<span id="L1238"><span class="lineNum">    1238</span>              : </span>
<span id="L1239"><span class="lineNum">    1239</span>              : /* Define to 1 if you have the `sinl' function. */</span>
<span id="L1240"><span class="lineNum">    1240</span>              : #define _GLIBCXX_HAVE_SINL 1</span>
<span id="L1241"><span class="lineNum">    1241</span>              : </span>
<span id="L1242"><span class="lineNum">    1242</span>              : /* Defined if sleep exists. */</span>
<span id="L1243"><span class="lineNum">    1243</span>              : /* #undef _GLIBCXX_HAVE_SLEEP */</span>
<span id="L1244"><span class="lineNum">    1244</span>              : </span>
<span id="L1245"><span class="lineNum">    1245</span>              : /* Define to 1 if you have the `sockatmark' function. */</span>
<span id="L1246"><span class="lineNum">    1246</span>              : #define _GLIBCXX_HAVE_SOCKATMARK 1</span>
<span id="L1247"><span class="lineNum">    1247</span>              : </span>
<span id="L1248"><span class="lineNum">    1248</span>              : /* Define to 1 if you have the `sqrtf' function. */</span>
<span id="L1249"><span class="lineNum">    1249</span>              : #define _GLIBCXX_HAVE_SQRTF 1</span>
<span id="L1250"><span class="lineNum">    1250</span>              : </span>
<span id="L1251"><span class="lineNum">    1251</span>              : /* Define to 1 if you have the `sqrtl' function. */</span>
<span id="L1252"><span class="lineNum">    1252</span>              : #define _GLIBCXX_HAVE_SQRTL 1</span>
<span id="L1253"><span class="lineNum">    1253</span>              : </span>
<span id="L1254"><span class="lineNum">    1254</span>              : /* Define if the &lt;stacktrace&gt; header is supported. */</span>
<span id="L1255"><span class="lineNum">    1255</span>              : #define _GLIBCXX_HAVE_STACKTRACE 1</span>
<span id="L1256"><span class="lineNum">    1256</span>              : </span>
<span id="L1257"><span class="lineNum">    1257</span>              : /* Define to 1 if you have the &lt;stdalign.h&gt; header file. */</span>
<span id="L1258"><span class="lineNum">    1258</span>              : #define _GLIBCXX_HAVE_STDALIGN_H 1</span>
<span id="L1259"><span class="lineNum">    1259</span>              : </span>
<span id="L1260"><span class="lineNum">    1260</span>              : /* Define to 1 if you have the &lt;stdbool.h&gt; header file. */</span>
<span id="L1261"><span class="lineNum">    1261</span>              : #define _GLIBCXX_HAVE_STDBOOL_H 1</span>
<span id="L1262"><span class="lineNum">    1262</span>              : </span>
<span id="L1263"><span class="lineNum">    1263</span>              : /* Define to 1 if you have the &lt;stdint.h&gt; header file. */</span>
<span id="L1264"><span class="lineNum">    1264</span>              : #define _GLIBCXX_HAVE_STDINT_H 1</span>
<span id="L1265"><span class="lineNum">    1265</span>              : </span>
<span id="L1266"><span class="lineNum">    1266</span>              : /* Define to 1 if you have the &lt;stdlib.h&gt; header file. */</span>
<span id="L1267"><span class="lineNum">    1267</span>              : #define _GLIBCXX_HAVE_STDLIB_H 1</span>
<span id="L1268"><span class="lineNum">    1268</span>              : </span>
<span id="L1269"><span class="lineNum">    1269</span>              : /* Define if strerror_l is available in &lt;string.h&gt;. */</span>
<span id="L1270"><span class="lineNum">    1270</span>              : #define _GLIBCXX_HAVE_STRERROR_L 1</span>
<span id="L1271"><span class="lineNum">    1271</span>              : </span>
<span id="L1272"><span class="lineNum">    1272</span>              : /* Define if strerror_r is available in &lt;string.h&gt;. */</span>
<span id="L1273"><span class="lineNum">    1273</span>              : #define _GLIBCXX_HAVE_STRERROR_R 1</span>
<span id="L1274"><span class="lineNum">    1274</span>              : </span>
<span id="L1275"><span class="lineNum">    1275</span>              : /* Define to 1 if you have the &lt;strings.h&gt; header file. */</span>
<span id="L1276"><span class="lineNum">    1276</span>              : #define _GLIBCXX_HAVE_STRINGS_H 1</span>
<span id="L1277"><span class="lineNum">    1277</span>              : </span>
<span id="L1278"><span class="lineNum">    1278</span>              : /* Define to 1 if you have the &lt;string.h&gt; header file. */</span>
<span id="L1279"><span class="lineNum">    1279</span>              : #define _GLIBCXX_HAVE_STRING_H 1</span>
<span id="L1280"><span class="lineNum">    1280</span>              : </span>
<span id="L1281"><span class="lineNum">    1281</span>              : /* Define to 1 if you have the `strtof' function. */</span>
<span id="L1282"><span class="lineNum">    1282</span>              : #define _GLIBCXX_HAVE_STRTOF 1</span>
<span id="L1283"><span class="lineNum">    1283</span>              : </span>
<span id="L1284"><span class="lineNum">    1284</span>              : /* Define to 1 if you have the `strtold' function. */</span>
<span id="L1285"><span class="lineNum">    1285</span>              : #define _GLIBCXX_HAVE_STRTOLD 1</span>
<span id="L1286"><span class="lineNum">    1286</span>              : </span>
<span id="L1287"><span class="lineNum">    1287</span>              : /* Define to 1 if `d_type' is a member of `struct dirent'. */</span>
<span id="L1288"><span class="lineNum">    1288</span>              : #define _GLIBCXX_HAVE_STRUCT_DIRENT_D_TYPE 1</span>
<span id="L1289"><span class="lineNum">    1289</span>              : </span>
<span id="L1290"><span class="lineNum">    1290</span>              : /* Define if strxfrm_l is available in &lt;string.h&gt;. */</span>
<span id="L1291"><span class="lineNum">    1291</span>              : #define _GLIBCXX_HAVE_STRXFRM_L 1</span>
<span id="L1292"><span class="lineNum">    1292</span>              : </span>
<span id="L1293"><span class="lineNum">    1293</span>              : /* Define if symlink is available in &lt;unistd.h&gt;. */</span>
<span id="L1294"><span class="lineNum">    1294</span>              : #define _GLIBCXX_HAVE_SYMLINK 1</span>
<span id="L1295"><span class="lineNum">    1295</span>              : </span>
<span id="L1296"><span class="lineNum">    1296</span>              : /* Define to 1 if the target runtime linker supports binding the same symbol</span>
<span id="L1297"><span class="lineNum">    1297</span>              :    to different versions. */</span>
<span id="L1298"><span class="lineNum">    1298</span>              : #define _GLIBCXX_HAVE_SYMVER_SYMBOL_RENAMING_RUNTIME_SUPPORT 1</span>
<span id="L1299"><span class="lineNum">    1299</span>              : </span>
<span id="L1300"><span class="lineNum">    1300</span>              : /* Define to 1 if you have the &lt;sys/filio.h&gt; header file. */</span>
<span id="L1301"><span class="lineNum">    1301</span>              : /* #undef _GLIBCXX_HAVE_SYS_FILIO_H */</span>
<span id="L1302"><span class="lineNum">    1302</span>              : </span>
<span id="L1303"><span class="lineNum">    1303</span>              : /* Define to 1 if you have the &lt;sys/ioctl.h&gt; header file. */</span>
<span id="L1304"><span class="lineNum">    1304</span>              : #define _GLIBCXX_HAVE_SYS_IOCTL_H 1</span>
<span id="L1305"><span class="lineNum">    1305</span>              : </span>
<span id="L1306"><span class="lineNum">    1306</span>              : /* Define to 1 if you have the &lt;sys/ipc.h&gt; header file. */</span>
<span id="L1307"><span class="lineNum">    1307</span>              : #define _GLIBCXX_HAVE_SYS_IPC_H 1</span>
<span id="L1308"><span class="lineNum">    1308</span>              : </span>
<span id="L1309"><span class="lineNum">    1309</span>              : /* Define to 1 if you have the &lt;sys/isa_defs.h&gt; header file. */</span>
<span id="L1310"><span class="lineNum">    1310</span>              : /* #undef _GLIBCXX_HAVE_SYS_ISA_DEFS_H */</span>
<span id="L1311"><span class="lineNum">    1311</span>              : </span>
<span id="L1312"><span class="lineNum">    1312</span>              : /* Define to 1 if you have the &lt;sys/machine.h&gt; header file. */</span>
<span id="L1313"><span class="lineNum">    1313</span>              : /* #undef _GLIBCXX_HAVE_SYS_MACHINE_H */</span>
<span id="L1314"><span class="lineNum">    1314</span>              : </span>
<span id="L1315"><span class="lineNum">    1315</span>              : /* Define to 1 if you have the &lt;sys/mman.h&gt; header file. */</span>
<span id="L1316"><span class="lineNum">    1316</span>              : #define _GLIBCXX_HAVE_SYS_MMAN_H 1</span>
<span id="L1317"><span class="lineNum">    1317</span>              : </span>
<span id="L1318"><span class="lineNum">    1318</span>              : /* Define to 1 if you have the &lt;sys/param.h&gt; header file. */</span>
<span id="L1319"><span class="lineNum">    1319</span>              : #define _GLIBCXX_HAVE_SYS_PARAM_H 1</span>
<span id="L1320"><span class="lineNum">    1320</span>              : </span>
<span id="L1321"><span class="lineNum">    1321</span>              : /* Define to 1 if you have the &lt;sys/resource.h&gt; header file. */</span>
<span id="L1322"><span class="lineNum">    1322</span>              : #define _GLIBCXX_HAVE_SYS_RESOURCE_H 1</span>
<span id="L1323"><span class="lineNum">    1323</span>              : </span>
<span id="L1324"><span class="lineNum">    1324</span>              : /* Define to 1 if you have a suitable &lt;sys/sdt.h&gt; header file */</span>
<span id="L1325"><span class="lineNum">    1325</span>              : #define _GLIBCXX_HAVE_SYS_SDT_H 1</span>
<span id="L1326"><span class="lineNum">    1326</span>              : </span>
<span id="L1327"><span class="lineNum">    1327</span>              : /* Define to 1 if you have the &lt;sys/sem.h&gt; header file. */</span>
<span id="L1328"><span class="lineNum">    1328</span>              : #define _GLIBCXX_HAVE_SYS_SEM_H 1</span>
<span id="L1329"><span class="lineNum">    1329</span>              : </span>
<span id="L1330"><span class="lineNum">    1330</span>              : /* Define to 1 if you have the &lt;sys/socket.h&gt; header file. */</span>
<span id="L1331"><span class="lineNum">    1331</span>              : #define _GLIBCXX_HAVE_SYS_SOCKET_H 1</span>
<span id="L1332"><span class="lineNum">    1332</span>              : </span>
<span id="L1333"><span class="lineNum">    1333</span>              : /* Define to 1 if you have the &lt;sys/statvfs.h&gt; header file. */</span>
<span id="L1334"><span class="lineNum">    1334</span>              : #define _GLIBCXX_HAVE_SYS_STATVFS_H 1</span>
<span id="L1335"><span class="lineNum">    1335</span>              : </span>
<span id="L1336"><span class="lineNum">    1336</span>              : /* Define to 1 if you have the &lt;sys/stat.h&gt; header file. */</span>
<span id="L1337"><span class="lineNum">    1337</span>              : #define _GLIBCXX_HAVE_SYS_STAT_H 1</span>
<span id="L1338"><span class="lineNum">    1338</span>              : </span>
<span id="L1339"><span class="lineNum">    1339</span>              : /* Define to 1 if you have the &lt;sys/sysinfo.h&gt; header file. */</span>
<span id="L1340"><span class="lineNum">    1340</span>              : #define _GLIBCXX_HAVE_SYS_SYSINFO_H 1</span>
<span id="L1341"><span class="lineNum">    1341</span>              : </span>
<span id="L1342"><span class="lineNum">    1342</span>              : /* Define to 1 if you have the &lt;sys/time.h&gt; header file. */</span>
<span id="L1343"><span class="lineNum">    1343</span>              : #define _GLIBCXX_HAVE_SYS_TIME_H 1</span>
<span id="L1344"><span class="lineNum">    1344</span>              : </span>
<span id="L1345"><span class="lineNum">    1345</span>              : /* Define to 1 if you have the &lt;sys/types.h&gt; header file. */</span>
<span id="L1346"><span class="lineNum">    1346</span>              : #define _GLIBCXX_HAVE_SYS_TYPES_H 1</span>
<span id="L1347"><span class="lineNum">    1347</span>              : </span>
<span id="L1348"><span class="lineNum">    1348</span>              : /* Define to 1 if you have the &lt;sys/uio.h&gt; header file. */</span>
<span id="L1349"><span class="lineNum">    1349</span>              : #define _GLIBCXX_HAVE_SYS_UIO_H 1</span>
<span id="L1350"><span class="lineNum">    1350</span>              : </span>
<span id="L1351"><span class="lineNum">    1351</span>              : /* Define if S_IFREG is available in &lt;sys/stat.h&gt;. */</span>
<span id="L1352"><span class="lineNum">    1352</span>              : /* #undef _GLIBCXX_HAVE_S_IFREG */</span>
<span id="L1353"><span class="lineNum">    1353</span>              : </span>
<span id="L1354"><span class="lineNum">    1354</span>              : /* Define if S_ISREG is available in &lt;sys/stat.h&gt;. */</span>
<span id="L1355"><span class="lineNum">    1355</span>              : #define _GLIBCXX_HAVE_S_ISREG 1</span>
<span id="L1356"><span class="lineNum">    1356</span>              : </span>
<span id="L1357"><span class="lineNum">    1357</span>              : /* Define to 1 if you have the `tanf' function. */</span>
<span id="L1358"><span class="lineNum">    1358</span>              : #define _GLIBCXX_HAVE_TANF 1</span>
<span id="L1359"><span class="lineNum">    1359</span>              : </span>
<span id="L1360"><span class="lineNum">    1360</span>              : /* Define to 1 if you have the `tanhf' function. */</span>
<span id="L1361"><span class="lineNum">    1361</span>              : #define _GLIBCXX_HAVE_TANHF 1</span>
<span id="L1362"><span class="lineNum">    1362</span>              : </span>
<span id="L1363"><span class="lineNum">    1363</span>              : /* Define to 1 if you have the `tanhl' function. */</span>
<span id="L1364"><span class="lineNum">    1364</span>              : #define _GLIBCXX_HAVE_TANHL 1</span>
<span id="L1365"><span class="lineNum">    1365</span>              : </span>
<span id="L1366"><span class="lineNum">    1366</span>              : /* Define to 1 if you have the `tanl' function. */</span>
<span id="L1367"><span class="lineNum">    1367</span>              : #define _GLIBCXX_HAVE_TANL 1</span>
<span id="L1368"><span class="lineNum">    1368</span>              : </span>
<span id="L1369"><span class="lineNum">    1369</span>              : /* Define to 1 if you have the &lt;tgmath.h&gt; header file. */</span>
<span id="L1370"><span class="lineNum">    1370</span>              : #define _GLIBCXX_HAVE_TGMATH_H 1</span>
<span id="L1371"><span class="lineNum">    1371</span>              : </span>
<span id="L1372"><span class="lineNum">    1372</span>              : /* Define to 1 if you have the `timespec_get' function. */</span>
<span id="L1373"><span class="lineNum">    1373</span>              : #define _GLIBCXX_HAVE_TIMESPEC_GET 1</span>
<span id="L1374"><span class="lineNum">    1374</span>              : </span>
<span id="L1375"><span class="lineNum">    1375</span>              : /* Define to 1 if the target supports thread-local storage. */</span>
<span id="L1376"><span class="lineNum">    1376</span>              : #define _GLIBCXX_HAVE_TLS 1</span>
<span id="L1377"><span class="lineNum">    1377</span>              : </span>
<span id="L1378"><span class="lineNum">    1378</span>              : /* Define if truncate is available in &lt;unistd.h&gt;. */</span>
<span id="L1379"><span class="lineNum">    1379</span>              : #define _GLIBCXX_HAVE_TRUNCATE 1</span>
<span id="L1380"><span class="lineNum">    1380</span>              : </span>
<span id="L1381"><span class="lineNum">    1381</span>              : /* Define to 1 if you have the &lt;uchar.h&gt; header file. */</span>
<span id="L1382"><span class="lineNum">    1382</span>              : #define _GLIBCXX_HAVE_UCHAR_H 1</span>
<span id="L1383"><span class="lineNum">    1383</span>              : </span>
<span id="L1384"><span class="lineNum">    1384</span>              : /* Define to 1 if you have the &lt;unistd.h&gt; header file. */</span>
<span id="L1385"><span class="lineNum">    1385</span>              : #define _GLIBCXX_HAVE_UNISTD_H 1</span>
<span id="L1386"><span class="lineNum">    1386</span>              : </span>
<span id="L1387"><span class="lineNum">    1387</span>              : /* Define if unlinkat is available in &lt;fcntl.h&gt;. */</span>
<span id="L1388"><span class="lineNum">    1388</span>              : #define _GLIBCXX_HAVE_UNLINKAT 1</span>
<span id="L1389"><span class="lineNum">    1389</span>              : </span>
<span id="L1390"><span class="lineNum">    1390</span>              : /* Define to 1 if you have the `uselocale' function. */</span>
<span id="L1391"><span class="lineNum">    1391</span>              : #define _GLIBCXX_HAVE_USELOCALE 1</span>
<span id="L1392"><span class="lineNum">    1392</span>              : </span>
<span id="L1393"><span class="lineNum">    1393</span>              : /* Defined if usleep exists. */</span>
<span id="L1394"><span class="lineNum">    1394</span>              : /* #undef _GLIBCXX_HAVE_USLEEP */</span>
<span id="L1395"><span class="lineNum">    1395</span>              : </span>
<span id="L1396"><span class="lineNum">    1396</span>              : /* Define to 1 if you have the &lt;utime.h&gt; header file. */</span>
<span id="L1397"><span class="lineNum">    1397</span>              : #define _GLIBCXX_HAVE_UTIME_H 1</span>
<span id="L1398"><span class="lineNum">    1398</span>              : </span>
<span id="L1399"><span class="lineNum">    1399</span>              : /* Defined if vfwscanf exists. */</span>
<span id="L1400"><span class="lineNum">    1400</span>              : #define _GLIBCXX_HAVE_VFWSCANF 1</span>
<span id="L1401"><span class="lineNum">    1401</span>              : </span>
<span id="L1402"><span class="lineNum">    1402</span>              : /* Defined if vswscanf exists. */</span>
<span id="L1403"><span class="lineNum">    1403</span>              : #define _GLIBCXX_HAVE_VSWSCANF 1</span>
<span id="L1404"><span class="lineNum">    1404</span>              : </span>
<span id="L1405"><span class="lineNum">    1405</span>              : /* Defined if vwscanf exists. */</span>
<span id="L1406"><span class="lineNum">    1406</span>              : #define _GLIBCXX_HAVE_VWSCANF 1</span>
<span id="L1407"><span class="lineNum">    1407</span>              : </span>
<span id="L1408"><span class="lineNum">    1408</span>              : /* Define to 1 if you have the &lt;wchar.h&gt; header file. */</span>
<span id="L1409"><span class="lineNum">    1409</span>              : #define _GLIBCXX_HAVE_WCHAR_H 1</span>
<span id="L1410"><span class="lineNum">    1410</span>              : </span>
<span id="L1411"><span class="lineNum">    1411</span>              : /* Defined if wcstof exists. */</span>
<span id="L1412"><span class="lineNum">    1412</span>              : #define _GLIBCXX_HAVE_WCSTOF 1</span>
<span id="L1413"><span class="lineNum">    1413</span>              : </span>
<span id="L1414"><span class="lineNum">    1414</span>              : /* Define to 1 if you have the &lt;wctype.h&gt; header file. */</span>
<span id="L1415"><span class="lineNum">    1415</span>              : #define _GLIBCXX_HAVE_WCTYPE_H 1</span>
<span id="L1416"><span class="lineNum">    1416</span>              : </span>
<span id="L1417"><span class="lineNum">    1417</span>              : /* Define to 1 if you have the &lt;windows.h&gt; header file. */</span>
<span id="L1418"><span class="lineNum">    1418</span>              : /* #undef _GLIBCXX_HAVE_WINDOWS_H */</span>
<span id="L1419"><span class="lineNum">    1419</span>              : </span>
<span id="L1420"><span class="lineNum">    1420</span>              : /* Define if writev is available in &lt;sys/uio.h&gt;. */</span>
<span id="L1421"><span class="lineNum">    1421</span>              : #define _GLIBCXX_HAVE_WRITEV 1</span>
<span id="L1422"><span class="lineNum">    1422</span>              : </span>
<span id="L1423"><span class="lineNum">    1423</span>              : /* Define to 1 if you have the &lt;xlocale.h&gt; header file. */</span>
<span id="L1424"><span class="lineNum">    1424</span>              : /* #undef _GLIBCXX_HAVE_XLOCALE_H */</span>
<span id="L1425"><span class="lineNum">    1425</span>              : </span>
<span id="L1426"><span class="lineNum">    1426</span>              : /* Define to 1 if you have the `_acosf' function. */</span>
<span id="L1427"><span class="lineNum">    1427</span>              : /* #undef _GLIBCXX_HAVE__ACOSF */</span>
<span id="L1428"><span class="lineNum">    1428</span>              : </span>
<span id="L1429"><span class="lineNum">    1429</span>              : /* Define to 1 if you have the `_acosl' function. */</span>
<span id="L1430"><span class="lineNum">    1430</span>              : /* #undef _GLIBCXX_HAVE__ACOSL */</span>
<span id="L1431"><span class="lineNum">    1431</span>              : </span>
<span id="L1432"><span class="lineNum">    1432</span>              : /* Define to 1 if you have the `_aligned_malloc' function. */</span>
<span id="L1433"><span class="lineNum">    1433</span>              : /* #undef _GLIBCXX_HAVE__ALIGNED_MALLOC */</span>
<span id="L1434"><span class="lineNum">    1434</span>              : </span>
<span id="L1435"><span class="lineNum">    1435</span>              : /* Define to 1 if you have the `_asinf' function. */</span>
<span id="L1436"><span class="lineNum">    1436</span>              : /* #undef _GLIBCXX_HAVE__ASINF */</span>
<span id="L1437"><span class="lineNum">    1437</span>              : </span>
<span id="L1438"><span class="lineNum">    1438</span>              : /* Define to 1 if you have the `_asinl' function. */</span>
<span id="L1439"><span class="lineNum">    1439</span>              : /* #undef _GLIBCXX_HAVE__ASINL */</span>
<span id="L1440"><span class="lineNum">    1440</span>              : </span>
<span id="L1441"><span class="lineNum">    1441</span>              : /* Define to 1 if you have the `_atan2f' function. */</span>
<span id="L1442"><span class="lineNum">    1442</span>              : /* #undef _GLIBCXX_HAVE__ATAN2F */</span>
<span id="L1443"><span class="lineNum">    1443</span>              : </span>
<span id="L1444"><span class="lineNum">    1444</span>              : /* Define to 1 if you have the `_atan2l' function. */</span>
<span id="L1445"><span class="lineNum">    1445</span>              : /* #undef _GLIBCXX_HAVE__ATAN2L */</span>
<span id="L1446"><span class="lineNum">    1446</span>              : </span>
<span id="L1447"><span class="lineNum">    1447</span>              : /* Define to 1 if you have the `_atanf' function. */</span>
<span id="L1448"><span class="lineNum">    1448</span>              : /* #undef _GLIBCXX_HAVE__ATANF */</span>
<span id="L1449"><span class="lineNum">    1449</span>              : </span>
<span id="L1450"><span class="lineNum">    1450</span>              : /* Define to 1 if you have the `_atanl' function. */</span>
<span id="L1451"><span class="lineNum">    1451</span>              : /* #undef _GLIBCXX_HAVE__ATANL */</span>
<span id="L1452"><span class="lineNum">    1452</span>              : </span>
<span id="L1453"><span class="lineNum">    1453</span>              : /* Define to 1 if you have the `_ceilf' function. */</span>
<span id="L1454"><span class="lineNum">    1454</span>              : /* #undef _GLIBCXX_HAVE__CEILF */</span>
<span id="L1455"><span class="lineNum">    1455</span>              : </span>
<span id="L1456"><span class="lineNum">    1456</span>              : /* Define to 1 if you have the `_ceill' function. */</span>
<span id="L1457"><span class="lineNum">    1457</span>              : /* #undef _GLIBCXX_HAVE__CEILL */</span>
<span id="L1458"><span class="lineNum">    1458</span>              : </span>
<span id="L1459"><span class="lineNum">    1459</span>              : /* Define to 1 if you have the `_cosf' function. */</span>
<span id="L1460"><span class="lineNum">    1460</span>              : /* #undef _GLIBCXX_HAVE__COSF */</span>
<span id="L1461"><span class="lineNum">    1461</span>              : </span>
<span id="L1462"><span class="lineNum">    1462</span>              : /* Define to 1 if you have the `_coshf' function. */</span>
<span id="L1463"><span class="lineNum">    1463</span>              : /* #undef _GLIBCXX_HAVE__COSHF */</span>
<span id="L1464"><span class="lineNum">    1464</span>              : </span>
<span id="L1465"><span class="lineNum">    1465</span>              : /* Define to 1 if you have the `_coshl' function. */</span>
<span id="L1466"><span class="lineNum">    1466</span>              : /* #undef _GLIBCXX_HAVE__COSHL */</span>
<span id="L1467"><span class="lineNum">    1467</span>              : </span>
<span id="L1468"><span class="lineNum">    1468</span>              : /* Define to 1 if you have the `_cosl' function. */</span>
<span id="L1469"><span class="lineNum">    1469</span>              : /* #undef _GLIBCXX_HAVE__COSL */</span>
<span id="L1470"><span class="lineNum">    1470</span>              : </span>
<span id="L1471"><span class="lineNum">    1471</span>              : /* Define to 1 if you have the `_expf' function. */</span>
<span id="L1472"><span class="lineNum">    1472</span>              : /* #undef _GLIBCXX_HAVE__EXPF */</span>
<span id="L1473"><span class="lineNum">    1473</span>              : </span>
<span id="L1474"><span class="lineNum">    1474</span>              : /* Define to 1 if you have the `_expl' function. */</span>
<span id="L1475"><span class="lineNum">    1475</span>              : /* #undef _GLIBCXX_HAVE__EXPL */</span>
<span id="L1476"><span class="lineNum">    1476</span>              : </span>
<span id="L1477"><span class="lineNum">    1477</span>              : /* Define to 1 if you have the `_fabsf' function. */</span>
<span id="L1478"><span class="lineNum">    1478</span>              : /* #undef _GLIBCXX_HAVE__FABSF */</span>
<span id="L1479"><span class="lineNum">    1479</span>              : </span>
<span id="L1480"><span class="lineNum">    1480</span>              : /* Define to 1 if you have the `_fabsl' function. */</span>
<span id="L1481"><span class="lineNum">    1481</span>              : /* #undef _GLIBCXX_HAVE__FABSL */</span>
<span id="L1482"><span class="lineNum">    1482</span>              : </span>
<span id="L1483"><span class="lineNum">    1483</span>              : /* Define to 1 if you have the `_finite' function. */</span>
<span id="L1484"><span class="lineNum">    1484</span>              : /* #undef _GLIBCXX_HAVE__FINITE */</span>
<span id="L1485"><span class="lineNum">    1485</span>              : </span>
<span id="L1486"><span class="lineNum">    1486</span>              : /* Define to 1 if you have the `_finitef' function. */</span>
<span id="L1487"><span class="lineNum">    1487</span>              : /* #undef _GLIBCXX_HAVE__FINITEF */</span>
<span id="L1488"><span class="lineNum">    1488</span>              : </span>
<span id="L1489"><span class="lineNum">    1489</span>              : /* Define to 1 if you have the `_finitel' function. */</span>
<span id="L1490"><span class="lineNum">    1490</span>              : /* #undef _GLIBCXX_HAVE__FINITEL */</span>
<span id="L1491"><span class="lineNum">    1491</span>              : </span>
<span id="L1492"><span class="lineNum">    1492</span>              : /* Define to 1 if you have the `_floorf' function. */</span>
<span id="L1493"><span class="lineNum">    1493</span>              : /* #undef _GLIBCXX_HAVE__FLOORF */</span>
<span id="L1494"><span class="lineNum">    1494</span>              : </span>
<span id="L1495"><span class="lineNum">    1495</span>              : /* Define to 1 if you have the `_floorl' function. */</span>
<span id="L1496"><span class="lineNum">    1496</span>              : /* #undef _GLIBCXX_HAVE__FLOORL */</span>
<span id="L1497"><span class="lineNum">    1497</span>              : </span>
<span id="L1498"><span class="lineNum">    1498</span>              : /* Define to 1 if you have the `_fmodf' function. */</span>
<span id="L1499"><span class="lineNum">    1499</span>              : /* #undef _GLIBCXX_HAVE__FMODF */</span>
<span id="L1500"><span class="lineNum">    1500</span>              : </span>
<span id="L1501"><span class="lineNum">    1501</span>              : /* Define to 1 if you have the `_fmodl' function. */</span>
<span id="L1502"><span class="lineNum">    1502</span>              : /* #undef _GLIBCXX_HAVE__FMODL */</span>
<span id="L1503"><span class="lineNum">    1503</span>              : </span>
<span id="L1504"><span class="lineNum">    1504</span>              : /* Define to 1 if you have the `_fpclass' function. */</span>
<span id="L1505"><span class="lineNum">    1505</span>              : /* #undef _GLIBCXX_HAVE__FPCLASS */</span>
<span id="L1506"><span class="lineNum">    1506</span>              : </span>
<span id="L1507"><span class="lineNum">    1507</span>              : /* Define to 1 if you have the `_frexpf' function. */</span>
<span id="L1508"><span class="lineNum">    1508</span>              : /* #undef _GLIBCXX_HAVE__FREXPF */</span>
<span id="L1509"><span class="lineNum">    1509</span>              : </span>
<span id="L1510"><span class="lineNum">    1510</span>              : /* Define to 1 if you have the `_frexpl' function. */</span>
<span id="L1511"><span class="lineNum">    1511</span>              : /* #undef _GLIBCXX_HAVE__FREXPL */</span>
<span id="L1512"><span class="lineNum">    1512</span>              : </span>
<span id="L1513"><span class="lineNum">    1513</span>              : /* Define to 1 if you have the `_hypot' function. */</span>
<span id="L1514"><span class="lineNum">    1514</span>              : /* #undef _GLIBCXX_HAVE__HYPOT */</span>
<span id="L1515"><span class="lineNum">    1515</span>              : </span>
<span id="L1516"><span class="lineNum">    1516</span>              : /* Define to 1 if you have the `_hypotf' function. */</span>
<span id="L1517"><span class="lineNum">    1517</span>              : /* #undef _GLIBCXX_HAVE__HYPOTF */</span>
<span id="L1518"><span class="lineNum">    1518</span>              : </span>
<span id="L1519"><span class="lineNum">    1519</span>              : /* Define to 1 if you have the `_hypotl' function. */</span>
<span id="L1520"><span class="lineNum">    1520</span>              : /* #undef _GLIBCXX_HAVE__HYPOTL */</span>
<span id="L1521"><span class="lineNum">    1521</span>              : </span>
<span id="L1522"><span class="lineNum">    1522</span>              : /* Define to 1 if you have the `_isinf' function. */</span>
<span id="L1523"><span class="lineNum">    1523</span>              : /* #undef _GLIBCXX_HAVE__ISINF */</span>
<span id="L1524"><span class="lineNum">    1524</span>              : </span>
<span id="L1525"><span class="lineNum">    1525</span>              : /* Define to 1 if you have the `_isinff' function. */</span>
<span id="L1526"><span class="lineNum">    1526</span>              : /* #undef _GLIBCXX_HAVE__ISINFF */</span>
<span id="L1527"><span class="lineNum">    1527</span>              : </span>
<span id="L1528"><span class="lineNum">    1528</span>              : /* Define to 1 if you have the `_isinfl' function. */</span>
<span id="L1529"><span class="lineNum">    1529</span>              : /* #undef _GLIBCXX_HAVE__ISINFL */</span>
<span id="L1530"><span class="lineNum">    1530</span>              : </span>
<span id="L1531"><span class="lineNum">    1531</span>              : /* Define to 1 if you have the `_isnan' function. */</span>
<span id="L1532"><span class="lineNum">    1532</span>              : /* #undef _GLIBCXX_HAVE__ISNAN */</span>
<span id="L1533"><span class="lineNum">    1533</span>              : </span>
<span id="L1534"><span class="lineNum">    1534</span>              : /* Define to 1 if you have the `_isnanf' function. */</span>
<span id="L1535"><span class="lineNum">    1535</span>              : /* #undef _GLIBCXX_HAVE__ISNANF */</span>
<span id="L1536"><span class="lineNum">    1536</span>              : </span>
<span id="L1537"><span class="lineNum">    1537</span>              : /* Define to 1 if you have the `_isnanl' function. */</span>
<span id="L1538"><span class="lineNum">    1538</span>              : /* #undef _GLIBCXX_HAVE__ISNANL */</span>
<span id="L1539"><span class="lineNum">    1539</span>              : </span>
<span id="L1540"><span class="lineNum">    1540</span>              : /* Define to 1 if you have the `_ldexpf' function. */</span>
<span id="L1541"><span class="lineNum">    1541</span>              : /* #undef _GLIBCXX_HAVE__LDEXPF */</span>
<span id="L1542"><span class="lineNum">    1542</span>              : </span>
<span id="L1543"><span class="lineNum">    1543</span>              : /* Define to 1 if you have the `_ldexpl' function. */</span>
<span id="L1544"><span class="lineNum">    1544</span>              : /* #undef _GLIBCXX_HAVE__LDEXPL */</span>
<span id="L1545"><span class="lineNum">    1545</span>              : </span>
<span id="L1546"><span class="lineNum">    1546</span>              : /* Define to 1 if you have the `_log10f' function. */</span>
<span id="L1547"><span class="lineNum">    1547</span>              : /* #undef _GLIBCXX_HAVE__LOG10F */</span>
<span id="L1548"><span class="lineNum">    1548</span>              : </span>
<span id="L1549"><span class="lineNum">    1549</span>              : /* Define to 1 if you have the `_log10l' function. */</span>
<span id="L1550"><span class="lineNum">    1550</span>              : /* #undef _GLIBCXX_HAVE__LOG10L */</span>
<span id="L1551"><span class="lineNum">    1551</span>              : </span>
<span id="L1552"><span class="lineNum">    1552</span>              : /* Define to 1 if you have the `_logf' function. */</span>
<span id="L1553"><span class="lineNum">    1553</span>              : /* #undef _GLIBCXX_HAVE__LOGF */</span>
<span id="L1554"><span class="lineNum">    1554</span>              : </span>
<span id="L1555"><span class="lineNum">    1555</span>              : /* Define to 1 if you have the `_logl' function. */</span>
<span id="L1556"><span class="lineNum">    1556</span>              : /* #undef _GLIBCXX_HAVE__LOGL */</span>
<span id="L1557"><span class="lineNum">    1557</span>              : </span>
<span id="L1558"><span class="lineNum">    1558</span>              : /* Define to 1 if you have the `_modf' function. */</span>
<span id="L1559"><span class="lineNum">    1559</span>              : /* #undef _GLIBCXX_HAVE__MODF */</span>
<span id="L1560"><span class="lineNum">    1560</span>              : </span>
<span id="L1561"><span class="lineNum">    1561</span>              : /* Define to 1 if you have the `_modff' function. */</span>
<span id="L1562"><span class="lineNum">    1562</span>              : /* #undef _GLIBCXX_HAVE__MODFF */</span>
<span id="L1563"><span class="lineNum">    1563</span>              : </span>
<span id="L1564"><span class="lineNum">    1564</span>              : /* Define to 1 if you have the `_modfl' function. */</span>
<span id="L1565"><span class="lineNum">    1565</span>              : /* #undef _GLIBCXX_HAVE__MODFL */</span>
<span id="L1566"><span class="lineNum">    1566</span>              : </span>
<span id="L1567"><span class="lineNum">    1567</span>              : /* Define to 1 if you have the `_powf' function. */</span>
<span id="L1568"><span class="lineNum">    1568</span>              : /* #undef _GLIBCXX_HAVE__POWF */</span>
<span id="L1569"><span class="lineNum">    1569</span>              : </span>
<span id="L1570"><span class="lineNum">    1570</span>              : /* Define to 1 if you have the `_powl' function. */</span>
<span id="L1571"><span class="lineNum">    1571</span>              : /* #undef _GLIBCXX_HAVE__POWL */</span>
<span id="L1572"><span class="lineNum">    1572</span>              : </span>
<span id="L1573"><span class="lineNum">    1573</span>              : /* Define to 1 if you have the `_qfpclass' function. */</span>
<span id="L1574"><span class="lineNum">    1574</span>              : /* #undef _GLIBCXX_HAVE__QFPCLASS */</span>
<span id="L1575"><span class="lineNum">    1575</span>              : </span>
<span id="L1576"><span class="lineNum">    1576</span>              : /* Define to 1 if you have the `_sincos' function. */</span>
<span id="L1577"><span class="lineNum">    1577</span>              : /* #undef _GLIBCXX_HAVE__SINCOS */</span>
<span id="L1578"><span class="lineNum">    1578</span>              : </span>
<span id="L1579"><span class="lineNum">    1579</span>              : /* Define to 1 if you have the `_sincosf' function. */</span>
<span id="L1580"><span class="lineNum">    1580</span>              : /* #undef _GLIBCXX_HAVE__SINCOSF */</span>
<span id="L1581"><span class="lineNum">    1581</span>              : </span>
<span id="L1582"><span class="lineNum">    1582</span>              : /* Define to 1 if you have the `_sincosl' function. */</span>
<span id="L1583"><span class="lineNum">    1583</span>              : /* #undef _GLIBCXX_HAVE__SINCOSL */</span>
<span id="L1584"><span class="lineNum">    1584</span>              : </span>
<span id="L1585"><span class="lineNum">    1585</span>              : /* Define to 1 if you have the `_sinf' function. */</span>
<span id="L1586"><span class="lineNum">    1586</span>              : /* #undef _GLIBCXX_HAVE__SINF */</span>
<span id="L1587"><span class="lineNum">    1587</span>              : </span>
<span id="L1588"><span class="lineNum">    1588</span>              : /* Define to 1 if you have the `_sinhf' function. */</span>
<span id="L1589"><span class="lineNum">    1589</span>              : /* #undef _GLIBCXX_HAVE__SINHF */</span>
<span id="L1590"><span class="lineNum">    1590</span>              : </span>
<span id="L1591"><span class="lineNum">    1591</span>              : /* Define to 1 if you have the `_sinhl' function. */</span>
<span id="L1592"><span class="lineNum">    1592</span>              : /* #undef _GLIBCXX_HAVE__SINHL */</span>
<span id="L1593"><span class="lineNum">    1593</span>              : </span>
<span id="L1594"><span class="lineNum">    1594</span>              : /* Define to 1 if you have the `_sinl' function. */</span>
<span id="L1595"><span class="lineNum">    1595</span>              : /* #undef _GLIBCXX_HAVE__SINL */</span>
<span id="L1596"><span class="lineNum">    1596</span>              : </span>
<span id="L1597"><span class="lineNum">    1597</span>              : /* Define to 1 if you have the `_sqrtf' function. */</span>
<span id="L1598"><span class="lineNum">    1598</span>              : /* #undef _GLIBCXX_HAVE__SQRTF */</span>
<span id="L1599"><span class="lineNum">    1599</span>              : </span>
<span id="L1600"><span class="lineNum">    1600</span>              : /* Define to 1 if you have the `_sqrtl' function. */</span>
<span id="L1601"><span class="lineNum">    1601</span>              : /* #undef _GLIBCXX_HAVE__SQRTL */</span>
<span id="L1602"><span class="lineNum">    1602</span>              : </span>
<span id="L1603"><span class="lineNum">    1603</span>              : /* Define to 1 if you have the `_tanf' function. */</span>
<span id="L1604"><span class="lineNum">    1604</span>              : /* #undef _GLIBCXX_HAVE__TANF */</span>
<span id="L1605"><span class="lineNum">    1605</span>              : </span>
<span id="L1606"><span class="lineNum">    1606</span>              : /* Define to 1 if you have the `_tanhf' function. */</span>
<span id="L1607"><span class="lineNum">    1607</span>              : /* #undef _GLIBCXX_HAVE__TANHF */</span>
<span id="L1608"><span class="lineNum">    1608</span>              : </span>
<span id="L1609"><span class="lineNum">    1609</span>              : /* Define to 1 if you have the `_tanhl' function. */</span>
<span id="L1610"><span class="lineNum">    1610</span>              : /* #undef _GLIBCXX_HAVE__TANHL */</span>
<span id="L1611"><span class="lineNum">    1611</span>              : </span>
<span id="L1612"><span class="lineNum">    1612</span>              : /* Define to 1 if you have the `_tanl' function. */</span>
<span id="L1613"><span class="lineNum">    1613</span>              : /* #undef _GLIBCXX_HAVE__TANL */</span>
<span id="L1614"><span class="lineNum">    1614</span>              : </span>
<span id="L1615"><span class="lineNum">    1615</span>              : /* Define to 1 if you have the `_wfopen' function. */</span>
<span id="L1616"><span class="lineNum">    1616</span>              : /* #undef _GLIBCXX_HAVE__WFOPEN */</span>
<span id="L1617"><span class="lineNum">    1617</span>              : </span>
<span id="L1618"><span class="lineNum">    1618</span>              : /* Define to 1 if you have the `__cxa_thread_atexit' function. */</span>
<span id="L1619"><span class="lineNum">    1619</span>              : /* #undef _GLIBCXX_HAVE___CXA_THREAD_ATEXIT */</span>
<span id="L1620"><span class="lineNum">    1620</span>              : </span>
<span id="L1621"><span class="lineNum">    1621</span>              : /* Define to 1 if you have the `__cxa_thread_atexit_impl' function. */</span>
<span id="L1622"><span class="lineNum">    1622</span>              : #define _GLIBCXX_HAVE___CXA_THREAD_ATEXIT_IMPL 1</span>
<span id="L1623"><span class="lineNum">    1623</span>              : </span>
<span id="L1624"><span class="lineNum">    1624</span>              : /* Define as const if the declaration of iconv() needs const. */</span>
<span id="L1625"><span class="lineNum">    1625</span>              : #define _GLIBCXX_ICONV_CONST </span>
<span id="L1626"><span class="lineNum">    1626</span>              : </span>
<span id="L1627"><span class="lineNum">    1627</span>              : /* Define to the sub-directory in which libtool stores uninstalled libraries.</span>
<span id="L1628"><span class="lineNum">    1628</span>              :    */</span>
<span id="L1629"><span class="lineNum">    1629</span>              : #define _GLIBCXX_LT_OBJDIR &quot;.libs/&quot;</span>
<span id="L1630"><span class="lineNum">    1630</span>              : </span>
<span id="L1631"><span class="lineNum">    1631</span>              : /* Name of package */</span>
<span id="L1632"><span class="lineNum">    1632</span>              : /* #undef _GLIBCXX_PACKAGE */</span>
<span id="L1633"><span class="lineNum">    1633</span>              : </span>
<span id="L1634"><span class="lineNum">    1634</span>              : /* Define to the address where bug reports for this package should be sent. */</span>
<span id="L1635"><span class="lineNum">    1635</span>              : #define _GLIBCXX_PACKAGE_BUGREPORT &quot;&quot;</span>
<span id="L1636"><span class="lineNum">    1636</span>              : </span>
<span id="L1637"><span class="lineNum">    1637</span>              : /* Define to the full name of this package. */</span>
<span id="L1638"><span class="lineNum">    1638</span>              : #define _GLIBCXX_PACKAGE_NAME &quot;package-unused&quot;</span>
<span id="L1639"><span class="lineNum">    1639</span>              : </span>
<span id="L1640"><span class="lineNum">    1640</span>              : /* Define to the full name and version of this package. */</span>
<span id="L1641"><span class="lineNum">    1641</span>              : #define _GLIBCXX_PACKAGE_STRING &quot;package-unused version-unused&quot;</span>
<span id="L1642"><span class="lineNum">    1642</span>              : </span>
<span id="L1643"><span class="lineNum">    1643</span>              : /* Define to the one symbol short name of this package. */</span>
<span id="L1644"><span class="lineNum">    1644</span>              : #define _GLIBCXX_PACKAGE_TARNAME &quot;libstdc++&quot;</span>
<span id="L1645"><span class="lineNum">    1645</span>              : </span>
<span id="L1646"><span class="lineNum">    1646</span>              : /* Define to the home page for this package. */</span>
<span id="L1647"><span class="lineNum">    1647</span>              : #define _GLIBCXX_PACKAGE_URL &quot;&quot;</span>
<span id="L1648"><span class="lineNum">    1648</span>              : </span>
<span id="L1649"><span class="lineNum">    1649</span>              : /* Define to the version of this package. */</span>
<span id="L1650"><span class="lineNum">    1650</span>              : #define _GLIBCXX_PACKAGE__GLIBCXX_VERSION &quot;version-unused&quot;</span>
<span id="L1651"><span class="lineNum">    1651</span>              : </span>
<span id="L1652"><span class="lineNum">    1652</span>              : /* Define to 1 if you have the ANSI C header files. */</span>
<span id="L1653"><span class="lineNum">    1653</span>              : #define _GLIBCXX_STDC_HEADERS 1</span>
<span id="L1654"><span class="lineNum">    1654</span>              : </span>
<span id="L1655"><span class="lineNum">    1655</span>              : /* Version number of package */</span>
<span id="L1656"><span class="lineNum">    1656</span>              : /* #undef _GLIBCXX_VERSION */</span>
<span id="L1657"><span class="lineNum">    1657</span>              : </span>
<span id="L1658"><span class="lineNum">    1658</span>              : /* Enable large inode numbers on Mac OS X 10.5.  */</span>
<span id="L1659"><span class="lineNum">    1659</span>              : #ifndef _GLIBCXX_DARWIN_USE_64_BIT_INODE</span>
<span id="L1660"><span class="lineNum">    1660</span>              : # define _GLIBCXX_DARWIN_USE_64_BIT_INODE 1</span>
<span id="L1661"><span class="lineNum">    1661</span>              : #endif</span>
<span id="L1662"><span class="lineNum">    1662</span>              : </span>
<span id="L1663"><span class="lineNum">    1663</span>              : /* Number of bits in a file offset, on hosts where this is settable. */</span>
<span id="L1664"><span class="lineNum">    1664</span>              : /* #undef _GLIBCXX_FILE_OFFSET_BITS */</span>
<span id="L1665"><span class="lineNum">    1665</span>              : </span>
<span id="L1666"><span class="lineNum">    1666</span>              : /* Define if C99 functions in &lt;complex.h&gt; should be used in &lt;complex&gt; for</span>
<span id="L1667"><span class="lineNum">    1667</span>              :    C++11. Using compiler builtins for these functions requires corresponding</span>
<span id="L1668"><span class="lineNum">    1668</span>              :    C99 library functions to be present. */</span>
<span id="L1669"><span class="lineNum">    1669</span>              : #define _GLIBCXX11_USE_C99_COMPLEX 1</span>
<span id="L1670"><span class="lineNum">    1670</span>              : </span>
<span id="L1671"><span class="lineNum">    1671</span>              : /* Define if C99 functions or macros in &lt;math.h&gt; should be imported in &lt;cmath&gt;</span>
<span id="L1672"><span class="lineNum">    1672</span>              :    in namespace std for C++11. */</span>
<span id="L1673"><span class="lineNum">    1673</span>              : #define _GLIBCXX11_USE_C99_MATH 1</span>
<span id="L1674"><span class="lineNum">    1674</span>              : </span>
<span id="L1675"><span class="lineNum">    1675</span>              : /* Define if C99 functions or macros in &lt;stdio.h&gt; should be imported in</span>
<span id="L1676"><span class="lineNum">    1676</span>              :    &lt;cstdio&gt; in namespace std for C++11. */</span>
<span id="L1677"><span class="lineNum">    1677</span>              : #define _GLIBCXX11_USE_C99_STDIO 1</span>
<span id="L1678"><span class="lineNum">    1678</span>              : </span>
<span id="L1679"><span class="lineNum">    1679</span>              : /* Define if C99 functions or macros in &lt;stdlib.h&gt; should be imported in</span>
<span id="L1680"><span class="lineNum">    1680</span>              :    &lt;cstdlib&gt; in namespace std for C++11. */</span>
<span id="L1681"><span class="lineNum">    1681</span>              : #define _GLIBCXX11_USE_C99_STDLIB 1</span>
<span id="L1682"><span class="lineNum">    1682</span>              : </span>
<span id="L1683"><span class="lineNum">    1683</span>              : /* Define if C99 functions or macros in &lt;wchar.h&gt; should be imported in</span>
<span id="L1684"><span class="lineNum">    1684</span>              :    &lt;cwchar&gt; in namespace std for C++11. */</span>
<span id="L1685"><span class="lineNum">    1685</span>              : #define _GLIBCXX11_USE_C99_WCHAR 1</span>
<span id="L1686"><span class="lineNum">    1686</span>              : </span>
<span id="L1687"><span class="lineNum">    1687</span>              : /* Define if C99 functions in &lt;complex.h&gt; should be used in &lt;complex&gt; for</span>
<span id="L1688"><span class="lineNum">    1688</span>              :    C++98. Using compiler builtins for these functions requires corresponding</span>
<span id="L1689"><span class="lineNum">    1689</span>              :    C99 library functions to be present. */</span>
<span id="L1690"><span class="lineNum">    1690</span>              : #define _GLIBCXX98_USE_C99_COMPLEX 1</span>
<span id="L1691"><span class="lineNum">    1691</span>              : </span>
<span id="L1692"><span class="lineNum">    1692</span>              : /* Define if C99 functions or macros in &lt;math.h&gt; should be imported in &lt;cmath&gt;</span>
<span id="L1693"><span class="lineNum">    1693</span>              :    in namespace std for C++98. */</span>
<span id="L1694"><span class="lineNum">    1694</span>              : #define _GLIBCXX98_USE_C99_MATH 1</span>
<span id="L1695"><span class="lineNum">    1695</span>              : </span>
<span id="L1696"><span class="lineNum">    1696</span>              : /* Define if C99 functions or macros in &lt;stdio.h&gt; should be imported in</span>
<span id="L1697"><span class="lineNum">    1697</span>              :    &lt;cstdio&gt; in namespace std for C++98. */</span>
<span id="L1698"><span class="lineNum">    1698</span>              : #define _GLIBCXX98_USE_C99_STDIO 1</span>
<span id="L1699"><span class="lineNum">    1699</span>              : </span>
<span id="L1700"><span class="lineNum">    1700</span>              : /* Define if C99 functions or macros in &lt;stdlib.h&gt; should be imported in</span>
<span id="L1701"><span class="lineNum">    1701</span>              :    &lt;cstdlib&gt; in namespace std for C++98. */</span>
<span id="L1702"><span class="lineNum">    1702</span>              : #define _GLIBCXX98_USE_C99_STDLIB 1</span>
<span id="L1703"><span class="lineNum">    1703</span>              : </span>
<span id="L1704"><span class="lineNum">    1704</span>              : /* Define if C99 functions or macros in &lt;wchar.h&gt; should be imported in</span>
<span id="L1705"><span class="lineNum">    1705</span>              :    &lt;cwchar&gt; in namespace std for C++98. */</span>
<span id="L1706"><span class="lineNum">    1706</span>              : #define _GLIBCXX98_USE_C99_WCHAR 1</span>
<span id="L1707"><span class="lineNum">    1707</span>              : </span>
<span id="L1708"><span class="lineNum">    1708</span>              : /* Define if the compiler supports C++11 atomics. */</span>
<span id="L1709"><span class="lineNum">    1709</span>              : #define _GLIBCXX_ATOMIC_BUILTINS 1</span>
<span id="L1710"><span class="lineNum">    1710</span>              : </span>
<span id="L1711"><span class="lineNum">    1711</span>              : /* Define if global objects can be aligned to</span>
<span id="L1712"><span class="lineNum">    1712</span>              :    std::hardware_destructive_interference_size. */</span>
<span id="L1713"><span class="lineNum">    1713</span>              : #define _GLIBCXX_CAN_ALIGNAS_DESTRUCTIVE_SIZE 1</span>
<span id="L1714"><span class="lineNum">    1714</span>              : </span>
<span id="L1715"><span class="lineNum">    1715</span>              : /* Define to use concept checking code from the boost libraries. */</span>
<span id="L1716"><span class="lineNum">    1716</span>              : /* #undef _GLIBCXX_CONCEPT_CHECKS */</span>
<span id="L1717"><span class="lineNum">    1717</span>              : </span>
<span id="L1718"><span class="lineNum">    1718</span>              : /* Define to 1 if a fully dynamic basic_string is wanted, 0 to disable,</span>
<span id="L1719"><span class="lineNum">    1719</span>              :    undefined for platform defaults */</span>
<span id="L1720"><span class="lineNum">    1720</span>              : #define _GLIBCXX_FULLY_DYNAMIC_STRING 0</span>
<span id="L1721"><span class="lineNum">    1721</span>              : </span>
<span id="L1722"><span class="lineNum">    1722</span>              : /* Define if gthreads library is available. */</span>
<span id="L1723"><span class="lineNum">    1723</span>              : #define _GLIBCXX_HAS_GTHREADS 1</span>
<span id="L1724"><span class="lineNum">    1724</span>              : </span>
<span id="L1725"><span class="lineNum">    1725</span>              : /* Define to 1 if a full hosted library is built, or 0 if freestanding. */</span>
<span id="L1726"><span class="lineNum">    1726</span>              : #define _GLIBCXX_HOSTED __STDC_HOSTED__</span>
<span id="L1727"><span class="lineNum">    1727</span>              : </span>
<span id="L1728"><span class="lineNum">    1728</span>              : /* Define if compatibility should be provided for alternative 128-bit long</span>
<span id="L1729"><span class="lineNum">    1729</span>              :    double formats. */</span>
<span id="L1730"><span class="lineNum">    1730</span>              : </span>
<span id="L1731"><span class="lineNum">    1731</span>              : /* Define if compatibility should be provided for -mlong-double-64. */</span>
<span id="L1732"><span class="lineNum">    1732</span>              : </span>
<span id="L1733"><span class="lineNum">    1733</span>              : /* Define to the letter to which size_t is mangled. */</span>
<span id="L1734"><span class="lineNum">    1734</span>              : #define _GLIBCXX_MANGLE_SIZE_T m</span>
<span id="L1735"><span class="lineNum">    1735</span>              : </span>
<span id="L1736"><span class="lineNum">    1736</span>              : /* Define if C99 llrint and llround functions are missing from &lt;math.h&gt;. */</span>
<span id="L1737"><span class="lineNum">    1737</span>              : /* #undef _GLIBCXX_NO_C99_ROUNDING_FUNCS */</span>
<span id="L1738"><span class="lineNum">    1738</span>              : </span>
<span id="L1739"><span class="lineNum">    1739</span>              : /* Defined if no way to sleep is available. */</span>
<span id="L1740"><span class="lineNum">    1740</span>              : /* #undef _GLIBCXX_NO_SLEEP */</span>
<span id="L1741"><span class="lineNum">    1741</span>              : </span>
<span id="L1742"><span class="lineNum">    1742</span>              : /* Define if ptrdiff_t is int. */</span>
<span id="L1743"><span class="lineNum">    1743</span>              : /* #undef _GLIBCXX_PTRDIFF_T_IS_INT */</span>
<span id="L1744"><span class="lineNum">    1744</span>              : </span>
<span id="L1745"><span class="lineNum">    1745</span>              : /* Define if using setrlimit to set resource limits during &quot;make check&quot; */</span>
<span id="L1746"><span class="lineNum">    1746</span>              : #define _GLIBCXX_RES_LIMITS 1</span>
<span id="L1747"><span class="lineNum">    1747</span>              : </span>
<span id="L1748"><span class="lineNum">    1748</span>              : /* Define if size_t is unsigned int. */</span>
<span id="L1749"><span class="lineNum">    1749</span>              : /* #undef _GLIBCXX_SIZE_T_IS_UINT */</span>
<span id="L1750"><span class="lineNum">    1750</span>              : </span>
<span id="L1751"><span class="lineNum">    1751</span>              : /* Define if static tzdata should be compiled into the library. */</span>
<span id="L1752"><span class="lineNum">    1752</span>              : #define _GLIBCXX_STATIC_TZDATA 1</span>
<span id="L1753"><span class="lineNum">    1753</span>              : </span>
<span id="L1754"><span class="lineNum">    1754</span>              : /* Define to the value of the EOF integer constant. */</span>
<span id="L1755"><span class="lineNum">    1755</span>              : #define _GLIBCXX_STDIO_EOF -1</span>
<span id="L1756"><span class="lineNum">    1756</span>              : </span>
<span id="L1757"><span class="lineNum">    1757</span>              : /* Define to the value of the SEEK_CUR integer constant. */</span>
<span id="L1758"><span class="lineNum">    1758</span>              : #define _GLIBCXX_STDIO_SEEK_CUR 1</span>
<span id="L1759"><span class="lineNum">    1759</span>              : </span>
<span id="L1760"><span class="lineNum">    1760</span>              : /* Define to the value of the SEEK_END integer constant. */</span>
<span id="L1761"><span class="lineNum">    1761</span>              : #define _GLIBCXX_STDIO_SEEK_END 2</span>
<span id="L1762"><span class="lineNum">    1762</span>              : </span>
<span id="L1763"><span class="lineNum">    1763</span>              : /* Define to use symbol versioning in the shared library. */</span>
<span id="L1764"><span class="lineNum">    1764</span>              : #define _GLIBCXX_SYMVER 1</span>
<span id="L1765"><span class="lineNum">    1765</span>              : </span>
<span id="L1766"><span class="lineNum">    1766</span>              : /* Define to use darwin versioning in the shared library. */</span>
<span id="L1767"><span class="lineNum">    1767</span>              : /* #undef _GLIBCXX_SYMVER_DARWIN */</span>
<span id="L1768"><span class="lineNum">    1768</span>              : </span>
<span id="L1769"><span class="lineNum">    1769</span>              : /* Define to use GNU versioning in the shared library. */</span>
<span id="L1770"><span class="lineNum">    1770</span>              : #define _GLIBCXX_SYMVER_GNU 1</span>
<span id="L1771"><span class="lineNum">    1771</span>              : </span>
<span id="L1772"><span class="lineNum">    1772</span>              : /* Define to use GNU namespace versioning in the shared library. */</span>
<span id="L1773"><span class="lineNum">    1773</span>              : /* #undef _GLIBCXX_SYMVER_GNU_NAMESPACE */</span>
<span id="L1774"><span class="lineNum">    1774</span>              : </span>
<span id="L1775"><span class="lineNum">    1775</span>              : /* Define to use Sun versioning in the shared library. */</span>
<span id="L1776"><span class="lineNum">    1776</span>              : /* #undef _GLIBCXX_SYMVER_SUN */</span>
<span id="L1777"><span class="lineNum">    1777</span>              : </span>
<span id="L1778"><span class="lineNum">    1778</span>              : /* Define if C11 functions in &lt;uchar.h&gt; should be imported into namespace std</span>
<span id="L1779"><span class="lineNum">    1779</span>              :    in &lt;cuchar&gt;. */</span>
<span id="L1780"><span class="lineNum">    1780</span>              : #define _GLIBCXX_USE_C11_UCHAR_CXX11 1</span>
<span id="L1781"><span class="lineNum">    1781</span>              : </span>
<span id="L1782"><span class="lineNum">    1782</span>              : /* Define if C99 functions or macros from &lt;wchar.h&gt;, &lt;math.h&gt;, &lt;complex.h&gt;,</span>
<span id="L1783"><span class="lineNum">    1783</span>              :    &lt;stdio.h&gt;, and &lt;stdlib.h&gt; can be used or exposed. */</span>
<span id="L1784"><span class="lineNum">    1784</span>              : #define _GLIBCXX_USE_C99 1</span>
<span id="L1785"><span class="lineNum">    1785</span>              : </span>
<span id="L1786"><span class="lineNum">    1786</span>              : /* Define if C99 functions in &lt;complex.h&gt; should be used in &lt;tr1/complex&gt;.</span>
<span id="L1787"><span class="lineNum">    1787</span>              :    Using compiler builtins for these functions requires corresponding C99</span>
<span id="L1788"><span class="lineNum">    1788</span>              :    library functions to be present. */</span>
<span id="L1789"><span class="lineNum">    1789</span>              : #define _GLIBCXX_USE_C99_COMPLEX_TR1 1</span>
<span id="L1790"><span class="lineNum">    1790</span>              : </span>
<span id="L1791"><span class="lineNum">    1791</span>              : /* Define if C99 functions in &lt;ctype.h&gt; should be imported in &lt;tr1/cctype&gt; in</span>
<span id="L1792"><span class="lineNum">    1792</span>              :    namespace std::tr1. */</span>
<span id="L1793"><span class="lineNum">    1793</span>              : #define _GLIBCXX_USE_C99_CTYPE_TR1 1</span>
<span id="L1794"><span class="lineNum">    1794</span>              : </span>
<span id="L1795"><span class="lineNum">    1795</span>              : /* Define if C99 functions in &lt;fenv.h&gt; should be imported in &lt;tr1/cfenv&gt; in</span>
<span id="L1796"><span class="lineNum">    1796</span>              :    namespace std::tr1. */</span>
<span id="L1797"><span class="lineNum">    1797</span>              : #define _GLIBCXX_USE_C99_FENV_TR1 1</span>
<span id="L1798"><span class="lineNum">    1798</span>              : </span>
<span id="L1799"><span class="lineNum">    1799</span>              : /* Define if C99 functions in &lt;inttypes.h&gt; should be imported in</span>
<span id="L1800"><span class="lineNum">    1800</span>              :    &lt;tr1/cinttypes&gt; in namespace std::tr1. */</span>
<span id="L1801"><span class="lineNum">    1801</span>              : #define _GLIBCXX_USE_C99_INTTYPES_TR1 1</span>
<span id="L1802"><span class="lineNum">    1802</span>              : </span>
<span id="L1803"><span class="lineNum">    1803</span>              : /* Define if wchar_t C99 functions in &lt;inttypes.h&gt; should be imported in</span>
<span id="L1804"><span class="lineNum">    1804</span>              :    &lt;tr1/cinttypes&gt; in namespace std::tr1. */</span>
<span id="L1805"><span class="lineNum">    1805</span>              : #define _GLIBCXX_USE_C99_INTTYPES_WCHAR_T_TR1 1</span>
<span id="L1806"><span class="lineNum">    1806</span>              : </span>
<span id="L1807"><span class="lineNum">    1807</span>              : /* Define if C99 functions or macros in &lt;math.h&gt; should be imported in</span>
<span id="L1808"><span class="lineNum">    1808</span>              :    &lt;tr1/cmath&gt; in namespace std::tr1. */</span>
<span id="L1809"><span class="lineNum">    1809</span>              : #define _GLIBCXX_USE_C99_MATH_TR1 1</span>
<span id="L1810"><span class="lineNum">    1810</span>              : </span>
<span id="L1811"><span class="lineNum">    1811</span>              : /* Define if C99 types in &lt;stdint.h&gt; should be imported in &lt;tr1/cstdint&gt; in</span>
<span id="L1812"><span class="lineNum">    1812</span>              :    namespace std::tr1. */</span>
<span id="L1813"><span class="lineNum">    1813</span>              : #define _GLIBCXX_USE_C99_STDINT_TR1 1</span>
<span id="L1814"><span class="lineNum">    1814</span>              : </span>
<span id="L1815"><span class="lineNum">    1815</span>              : /* Define if usable chdir is available in &lt;unistd.h&gt;. */</span>
<span id="L1816"><span class="lineNum">    1816</span>              : #define _GLIBCXX_USE_CHDIR 1</span>
<span id="L1817"><span class="lineNum">    1817</span>              : </span>
<span id="L1818"><span class="lineNum">    1818</span>              : /* Define if usable chmod is available in &lt;sys/stat.h&gt;. */</span>
<span id="L1819"><span class="lineNum">    1819</span>              : #define _GLIBCXX_USE_CHMOD 1</span>
<span id="L1820"><span class="lineNum">    1820</span>              : </span>
<span id="L1821"><span class="lineNum">    1821</span>              : /* Defined if clock_gettime syscall has monotonic and realtime clock support.</span>
<span id="L1822"><span class="lineNum">    1822</span>              :    */</span>
<span id="L1823"><span class="lineNum">    1823</span>              : /* #undef _GLIBCXX_USE_CLOCK_GETTIME_SYSCALL */</span>
<span id="L1824"><span class="lineNum">    1824</span>              : </span>
<span id="L1825"><span class="lineNum">    1825</span>              : /* Defined if clock_gettime has monotonic clock support. */</span>
<span id="L1826"><span class="lineNum">    1826</span>              : #define _GLIBCXX_USE_CLOCK_MONOTONIC 1</span>
<span id="L1827"><span class="lineNum">    1827</span>              : </span>
<span id="L1828"><span class="lineNum">    1828</span>              : /* Defined if clock_gettime has realtime clock support. */</span>
<span id="L1829"><span class="lineNum">    1829</span>              : #define _GLIBCXX_USE_CLOCK_REALTIME 1</span>
<span id="L1830"><span class="lineNum">    1830</span>              : </span>
<span id="L1831"><span class="lineNum">    1831</span>              : /* Define if ISO/IEC TR 24733 decimal floating point types are supported on</span>
<span id="L1832"><span class="lineNum">    1832</span>              :    this host. */</span>
<span id="L1833"><span class="lineNum">    1833</span>              : #define _GLIBCXX_USE_DECIMAL_FLOAT 1</span>
<span id="L1834"><span class="lineNum">    1834</span>              : </span>
<span id="L1835"><span class="lineNum">    1835</span>              : /* Define if /dev/random and /dev/urandom are available for</span>
<span id="L1836"><span class="lineNum">    1836</span>              :    std::random_device. */</span>
<span id="L1837"><span class="lineNum">    1837</span>              : #define _GLIBCXX_USE_DEV_RANDOM 1</span>
<span id="L1838"><span class="lineNum">    1838</span>              : </span>
<span id="L1839"><span class="lineNum">    1839</span>              : /* Define if fchmod is available in &lt;sys/stat.h&gt;. */</span>
<span id="L1840"><span class="lineNum">    1840</span>              : #define _GLIBCXX_USE_FCHMOD 1</span>
<span id="L1841"><span class="lineNum">    1841</span>              : </span>
<span id="L1842"><span class="lineNum">    1842</span>              : /* Define if fchmodat is available in &lt;sys/stat.h&gt;. */</span>
<span id="L1843"><span class="lineNum">    1843</span>              : #define _GLIBCXX_USE_FCHMODAT 1</span>
<span id="L1844"><span class="lineNum">    1844</span>              : </span>
<span id="L1845"><span class="lineNum">    1845</span>              : /* Define if fseeko and ftello are available. */</span>
<span id="L1846"><span class="lineNum">    1846</span>              : #define _GLIBCXX_USE_FSEEKO_FTELLO 1</span>
<span id="L1847"><span class="lineNum">    1847</span>              : </span>
<span id="L1848"><span class="lineNum">    1848</span>              : /* Define if usable getcwd is available in &lt;unistd.h&gt;. */</span>
<span id="L1849"><span class="lineNum">    1849</span>              : #define _GLIBCXX_USE_GETCWD 1</span>
<span id="L1850"><span class="lineNum">    1850</span>              : </span>
<span id="L1851"><span class="lineNum">    1851</span>              : /* Defined if gettimeofday is available. */</span>
<span id="L1852"><span class="lineNum">    1852</span>              : #define _GLIBCXX_USE_GETTIMEOFDAY 1</span>
<span id="L1853"><span class="lineNum">    1853</span>              : </span>
<span id="L1854"><span class="lineNum">    1854</span>              : /* Define if get_nprocs is available in &lt;sys/sysinfo.h&gt;. */</span>
<span id="L1855"><span class="lineNum">    1855</span>              : #define _GLIBCXX_USE_GET_NPROCS 1</span>
<span id="L1856"><span class="lineNum">    1856</span>              : </span>
<span id="L1857"><span class="lineNum">    1857</span>              : /* Define if init_priority should be used for iostream initialization. */</span>
<span id="L1858"><span class="lineNum">    1858</span>              : #define _GLIBCXX_USE_INIT_PRIORITY_ATTRIBUTE 1</span>
<span id="L1859"><span class="lineNum">    1859</span>              : </span>
<span id="L1860"><span class="lineNum">    1860</span>              : /* Define if LFS support is available. */</span>
<span id="L1861"><span class="lineNum">    1861</span>              : #define _GLIBCXX_USE_LFS 1</span>
<span id="L1862"><span class="lineNum">    1862</span>              : </span>
<span id="L1863"><span class="lineNum">    1863</span>              : /* Define if code specialized for long long should be used. */</span>
<span id="L1864"><span class="lineNum">    1864</span>              : #define _GLIBCXX_USE_LONG_LONG 1</span>
<span id="L1865"><span class="lineNum">    1865</span>              : </span>
<span id="L1866"><span class="lineNum">    1866</span>              : /* Define if lstat is available in &lt;sys/stat.h&gt;. */</span>
<span id="L1867"><span class="lineNum">    1867</span>              : #define _GLIBCXX_USE_LSTAT 1</span>
<span id="L1868"><span class="lineNum">    1868</span>              : </span>
<span id="L1869"><span class="lineNum">    1869</span>              : /* Define if usable mkdir is available in &lt;sys/stat.h&gt;. */</span>
<span id="L1870"><span class="lineNum">    1870</span>              : #define _GLIBCXX_USE_MKDIR 1</span>
<span id="L1871"><span class="lineNum">    1871</span>              : </span>
<span id="L1872"><span class="lineNum">    1872</span>              : /* Defined if nanosleep is available. */</span>
<span id="L1873"><span class="lineNum">    1873</span>              : #define _GLIBCXX_USE_NANOSLEEP 1</span>
<span id="L1874"><span class="lineNum">    1874</span>              : </span>
<span id="L1875"><span class="lineNum">    1875</span>              : /* Define if NLS translations are to be used. */</span>
<span id="L1876"><span class="lineNum">    1876</span>              : #define _GLIBCXX_USE_NLS 1</span>
<span id="L1877"><span class="lineNum">    1877</span>              : </span>
<span id="L1878"><span class="lineNum">    1878</span>              : /* Define if pthreads_num_processors_np is available in &lt;pthread.h&gt;. */</span>
<span id="L1879"><span class="lineNum">    1879</span>              : /* #undef _GLIBCXX_USE_PTHREADS_NUM_PROCESSORS_NP */</span>
<span id="L1880"><span class="lineNum">    1880</span>              : </span>
<span id="L1881"><span class="lineNum">    1881</span>              : /* Define if pthread_cond_clockwait is available in &lt;pthread.h&gt;. */</span>
<span id="L1882"><span class="lineNum">    1882</span>              : #define _GLIBCXX_USE_PTHREAD_COND_CLOCKWAIT 1</span>
<span id="L1883"><span class="lineNum">    1883</span>              : </span>
<span id="L1884"><span class="lineNum">    1884</span>              : /* Define if pthread_mutex_clocklock is available in &lt;pthread.h&gt;. */</span>
<span id="L1885"><span class="lineNum">    1885</span>              : #define _GLIBCXX_USE_PTHREAD_MUTEX_CLOCKLOCK 1</span>
<span id="L1886"><span class="lineNum">    1886</span>              : </span>
<span id="L1887"><span class="lineNum">    1887</span>              : /* Define if pthread_rwlock_clockrdlock and pthread_rwlock_clockwrlock are</span>
<span id="L1888"><span class="lineNum">    1888</span>              :    available in &lt;pthread.h&gt;. */</span>
<span id="L1889"><span class="lineNum">    1889</span>              : #define _GLIBCXX_USE_PTHREAD_RWLOCK_CLOCKLOCK 1</span>
<span id="L1890"><span class="lineNum">    1890</span>              : </span>
<span id="L1891"><span class="lineNum">    1891</span>              : /* Define if POSIX read/write locks are available in &lt;gthr.h&gt;. */</span>
<span id="L1892"><span class="lineNum">    1892</span>              : #define _GLIBCXX_USE_PTHREAD_RWLOCK_T 1</span>
<span id="L1893"><span class="lineNum">    1893</span>              : </span>
<span id="L1894"><span class="lineNum">    1894</span>              : /* Define if /dev/random and /dev/urandom are available for the random_device</span>
<span id="L1895"><span class="lineNum">    1895</span>              :    of TR1 (Chapter 5.1). */</span>
<span id="L1896"><span class="lineNum">    1896</span>              : #define _GLIBCXX_USE_RANDOM_TR1 1</span>
<span id="L1897"><span class="lineNum">    1897</span>              : </span>
<span id="L1898"><span class="lineNum">    1898</span>              : /* Define if usable realpath is available in &lt;stdlib.h&gt;. */</span>
<span id="L1899"><span class="lineNum">    1899</span>              : #define _GLIBCXX_USE_REALPATH 1</span>
<span id="L1900"><span class="lineNum">    1900</span>              : </span>
<span id="L1901"><span class="lineNum">    1901</span>              : /* Defined if sched_yield is available. */</span>
<span id="L1902"><span class="lineNum">    1902</span>              : #define _GLIBCXX_USE_SCHED_YIELD 1</span>
<span id="L1903"><span class="lineNum">    1903</span>              : </span>
<span id="L1904"><span class="lineNum">    1904</span>              : /* Define if _SC_NPROCESSORS_ONLN is available in &lt;unistd.h&gt;. */</span>
<span id="L1905"><span class="lineNum">    1905</span>              : #define _GLIBCXX_USE_SC_NPROCESSORS_ONLN 1</span>
<span id="L1906"><span class="lineNum">    1906</span>              : </span>
<span id="L1907"><span class="lineNum">    1907</span>              : /* Define if _SC_NPROC_ONLN is available in &lt;unistd.h&gt;. */</span>
<span id="L1908"><span class="lineNum">    1908</span>              : /* #undef _GLIBCXX_USE_SC_NPROC_ONLN */</span>
<span id="L1909"><span class="lineNum">    1909</span>              : </span>
<span id="L1910"><span class="lineNum">    1910</span>              : /* Define if sendfile is available in &lt;sys/sendfile.h&gt;. */</span>
<span id="L1911"><span class="lineNum">    1911</span>              : #define _GLIBCXX_USE_SENDFILE 1</span>
<span id="L1912"><span class="lineNum">    1912</span>              : </span>
<span id="L1913"><span class="lineNum">    1913</span>              : /* Define to restrict std::__basic_file&lt;&gt; to stdio APIs. */</span>
<span id="L1914"><span class="lineNum">    1914</span>              : /* #undef _GLIBCXX_USE_STDIO_PURE */</span>
<span id="L1915"><span class="lineNum">    1915</span>              : </span>
<span id="L1916"><span class="lineNum">    1916</span>              : /* Define if struct stat has timespec members. */</span>
<span id="L1917"><span class="lineNum">    1917</span>              : #define _GLIBCXX_USE_ST_MTIM 1</span>
<span id="L1918"><span class="lineNum">    1918</span>              : </span>
<span id="L1919"><span class="lineNum">    1919</span>              : /* Define if sysctl(), CTL_HW and HW_NCPU are available in &lt;sys/sysctl.h&gt;. */</span>
<span id="L1920"><span class="lineNum">    1920</span>              : /* #undef _GLIBCXX_USE_SYSCTL_HW_NCPU */</span>
<span id="L1921"><span class="lineNum">    1921</span>              : </span>
<span id="L1922"><span class="lineNum">    1922</span>              : /* Define if obsolescent tmpnam is available in &lt;stdio.h&gt;. */</span>
<span id="L1923"><span class="lineNum">    1923</span>              : #define _GLIBCXX_USE_TMPNAM 1</span>
<span id="L1924"><span class="lineNum">    1924</span>              : </span>
<span id="L1925"><span class="lineNum">    1925</span>              : /* Define if c8rtomb and mbrtoc8 functions in &lt;uchar.h&gt; should be imported</span>
<span id="L1926"><span class="lineNum">    1926</span>              :    into namespace std in &lt;cuchar&gt; for C++20. */</span>
<span id="L1927"><span class="lineNum">    1927</span>              : #define _GLIBCXX_USE_UCHAR_C8RTOMB_MBRTOC8_CXX20 1</span>
<span id="L1928"><span class="lineNum">    1928</span>              : </span>
<span id="L1929"><span class="lineNum">    1929</span>              : /* Define if c8rtomb and mbrtoc8 functions in &lt;uchar.h&gt; should be imported</span>
<span id="L1930"><span class="lineNum">    1930</span>              :    into namespace std in &lt;cuchar&gt; for -fchar8_t. */</span>
<span id="L1931"><span class="lineNum">    1931</span>              : #define _GLIBCXX_USE_UCHAR_C8RTOMB_MBRTOC8_FCHAR8_T 1</span>
<span id="L1932"><span class="lineNum">    1932</span>              : </span>
<span id="L1933"><span class="lineNum">    1933</span>              : /* Define if utime is available in &lt;utime.h&gt;. */</span>
<span id="L1934"><span class="lineNum">    1934</span>              : #define _GLIBCXX_USE_UTIME 1</span>
<span id="L1935"><span class="lineNum">    1935</span>              : </span>
<span id="L1936"><span class="lineNum">    1936</span>              : /* Define if utimensat and UTIME_OMIT are available in &lt;sys/stat.h&gt; and</span>
<span id="L1937"><span class="lineNum">    1937</span>              :    AT_FDCWD in &lt;fcntl.h&gt;. */</span>
<span id="L1938"><span class="lineNum">    1938</span>              : #define _GLIBCXX_USE_UTIMENSAT 1</span>
<span id="L1939"><span class="lineNum">    1939</span>              : </span>
<span id="L1940"><span class="lineNum">    1940</span>              : /* Define if code specialized for wchar_t should be used. */</span>
<span id="L1941"><span class="lineNum">    1941</span>              : #define _GLIBCXX_USE_WCHAR_T 1</span>
<span id="L1942"><span class="lineNum">    1942</span>              : </span>
<span id="L1943"><span class="lineNum">    1943</span>              : /* Defined if Sleep exists. */</span>
<span id="L1944"><span class="lineNum">    1944</span>              : /* #undef _GLIBCXX_USE_WIN32_SLEEP */</span>
<span id="L1945"><span class="lineNum">    1945</span>              : </span>
<span id="L1946"><span class="lineNum">    1946</span>              : /* Define to 1 if a verbose library is built, or 0 otherwise. */</span>
<span id="L1947"><span class="lineNum">    1947</span>              : #define _GLIBCXX_VERBOSE 1</span>
<span id="L1948"><span class="lineNum">    1948</span>              : </span>
<span id="L1949"><span class="lineNum">    1949</span>              : /* Defined if as can handle rdrand. */</span>
<span id="L1950"><span class="lineNum">    1950</span>              : #define _GLIBCXX_X86_RDRAND 1</span>
<span id="L1951"><span class="lineNum">    1951</span>              : </span>
<span id="L1952"><span class="lineNum">    1952</span>              : /* Defined if as can handle rdseed. */</span>
<span id="L1953"><span class="lineNum">    1953</span>              : #define _GLIBCXX_X86_RDSEED 1</span>
<span id="L1954"><span class="lineNum">    1954</span>              : </span>
<span id="L1955"><span class="lineNum">    1955</span>              : /* Define if a directory should be searched for tzdata files. */</span>
<span id="L1956"><span class="lineNum">    1956</span>              : #define _GLIBCXX_ZONEINFO_DIR &quot;/usr/share/zoneinfo&quot;</span>
<span id="L1957"><span class="lineNum">    1957</span>              : </span>
<span id="L1958"><span class="lineNum">    1958</span>              : /* Define to 1 if mutex_timedlock is available. */</span>
<span id="L1959"><span class="lineNum">    1959</span>              : #define _GTHREAD_USE_MUTEX_TIMEDLOCK 1</span>
<span id="L1960"><span class="lineNum">    1960</span>              : </span>
<span id="L1961"><span class="lineNum">    1961</span>              : /* Define for large files, on AIX-style hosts. */</span>
<span id="L1962"><span class="lineNum">    1962</span>              : /* #undef _GLIBCXX_LARGE_FILES */</span>
<span id="L1963"><span class="lineNum">    1963</span>              : </span>
<span id="L1964"><span class="lineNum">    1964</span>              : /* Define if all C++11 floating point overloads are available in &lt;math.h&gt;.  */</span>
<span id="L1965"><span class="lineNum">    1965</span>              : #if __cplusplus &gt;= 201103L</span>
<span id="L1966"><span class="lineNum">    1966</span>              : /* #undef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP */</span>
<span id="L1967"><span class="lineNum">    1967</span>              : #endif</span>
<span id="L1968"><span class="lineNum">    1968</span>              : </span>
<span id="L1969"><span class="lineNum">    1969</span>              : /* Define if all C++11 integral type overloads are available in &lt;math.h&gt;.  */</span>
<span id="L1970"><span class="lineNum">    1970</span>              : #if __cplusplus &gt;= 201103L</span>
<span id="L1971"><span class="lineNum">    1971</span>              : /* #undef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT */</span>
<span id="L1972"><span class="lineNum">    1972</span>              : #endif</span>
<span id="L1973"><span class="lineNum">    1973</span>              : </span>
<span id="L1974"><span class="lineNum">    1974</span>              : #if defined (_GLIBCXX_HAVE__ACOSF) &amp;&amp; ! defined (_GLIBCXX_HAVE_ACOSF)</span>
<span id="L1975"><span class="lineNum">    1975</span>              : # define _GLIBCXX_HAVE_ACOSF 1</span>
<span id="L1976"><span class="lineNum">    1976</span>              : # define acosf _acosf</span>
<span id="L1977"><span class="lineNum">    1977</span>              : #endif</span>
<span id="L1978"><span class="lineNum">    1978</span>              : </span>
<span id="L1979"><span class="lineNum">    1979</span>              : #if defined (_GLIBCXX_HAVE__ACOSL) &amp;&amp; ! defined (_GLIBCXX_HAVE_ACOSL)</span>
<span id="L1980"><span class="lineNum">    1980</span>              : # define _GLIBCXX_HAVE_ACOSL 1</span>
<span id="L1981"><span class="lineNum">    1981</span>              : # define acosl _acosl</span>
<span id="L1982"><span class="lineNum">    1982</span>              : #endif</span>
<span id="L1983"><span class="lineNum">    1983</span>              : </span>
<span id="L1984"><span class="lineNum">    1984</span>              : #if defined (_GLIBCXX_HAVE__ASINF) &amp;&amp; ! defined (_GLIBCXX_HAVE_ASINF)</span>
<span id="L1985"><span class="lineNum">    1985</span>              : # define _GLIBCXX_HAVE_ASINF 1</span>
<span id="L1986"><span class="lineNum">    1986</span>              : # define asinf _asinf</span>
<span id="L1987"><span class="lineNum">    1987</span>              : #endif</span>
<span id="L1988"><span class="lineNum">    1988</span>              : </span>
<span id="L1989"><span class="lineNum">    1989</span>              : #if defined (_GLIBCXX_HAVE__ASINL) &amp;&amp; ! defined (_GLIBCXX_HAVE_ASINL)</span>
<span id="L1990"><span class="lineNum">    1990</span>              : # define _GLIBCXX_HAVE_ASINL 1</span>
<span id="L1991"><span class="lineNum">    1991</span>              : # define asinl _asinl</span>
<span id="L1992"><span class="lineNum">    1992</span>              : #endif</span>
<span id="L1993"><span class="lineNum">    1993</span>              : </span>
<span id="L1994"><span class="lineNum">    1994</span>              : #if defined (_GLIBCXX_HAVE__ATAN2F) &amp;&amp; ! defined (_GLIBCXX_HAVE_ATAN2F)</span>
<span id="L1995"><span class="lineNum">    1995</span>              : # define _GLIBCXX_HAVE_ATAN2F 1</span>
<span id="L1996"><span class="lineNum">    1996</span>              : # define atan2f _atan2f</span>
<span id="L1997"><span class="lineNum">    1997</span>              : #endif</span>
<span id="L1998"><span class="lineNum">    1998</span>              : </span>
<span id="L1999"><span class="lineNum">    1999</span>              : #if defined (_GLIBCXX_HAVE__ATAN2L) &amp;&amp; ! defined (_GLIBCXX_HAVE_ATAN2L)</span>
<span id="L2000"><span class="lineNum">    2000</span>              : # define _GLIBCXX_HAVE_ATAN2L 1</span>
<span id="L2001"><span class="lineNum">    2001</span>              : # define atan2l _atan2l</span>
<span id="L2002"><span class="lineNum">    2002</span>              : #endif</span>
<span id="L2003"><span class="lineNum">    2003</span>              : </span>
<span id="L2004"><span class="lineNum">    2004</span>              : #if defined (_GLIBCXX_HAVE__ATANF) &amp;&amp; ! defined (_GLIBCXX_HAVE_ATANF)</span>
<span id="L2005"><span class="lineNum">    2005</span>              : # define _GLIBCXX_HAVE_ATANF 1</span>
<span id="L2006"><span class="lineNum">    2006</span>              : # define atanf _atanf</span>
<span id="L2007"><span class="lineNum">    2007</span>              : #endif</span>
<span id="L2008"><span class="lineNum">    2008</span>              : </span>
<span id="L2009"><span class="lineNum">    2009</span>              : #if defined (_GLIBCXX_HAVE__ATANL) &amp;&amp; ! defined (_GLIBCXX_HAVE_ATANL)</span>
<span id="L2010"><span class="lineNum">    2010</span>              : # define _GLIBCXX_HAVE_ATANL 1</span>
<span id="L2011"><span class="lineNum">    2011</span>              : # define atanl _atanl</span>
<span id="L2012"><span class="lineNum">    2012</span>              : #endif</span>
<span id="L2013"><span class="lineNum">    2013</span>              : </span>
<span id="L2014"><span class="lineNum">    2014</span>              : #if defined (_GLIBCXX_HAVE__CEILF) &amp;&amp; ! defined (_GLIBCXX_HAVE_CEILF)</span>
<span id="L2015"><span class="lineNum">    2015</span>              : # define _GLIBCXX_HAVE_CEILF 1</span>
<span id="L2016"><span class="lineNum">    2016</span>              : # define ceilf _ceilf</span>
<span id="L2017"><span class="lineNum">    2017</span>              : #endif</span>
<span id="L2018"><span class="lineNum">    2018</span>              : </span>
<span id="L2019"><span class="lineNum">    2019</span>              : #if defined (_GLIBCXX_HAVE__CEILL) &amp;&amp; ! defined (_GLIBCXX_HAVE_CEILL)</span>
<span id="L2020"><span class="lineNum">    2020</span>              : # define _GLIBCXX_HAVE_CEILL 1</span>
<span id="L2021"><span class="lineNum">    2021</span>              : # define ceill _ceill</span>
<span id="L2022"><span class="lineNum">    2022</span>              : #endif</span>
<span id="L2023"><span class="lineNum">    2023</span>              : </span>
<span id="L2024"><span class="lineNum">    2024</span>              : #if defined (_GLIBCXX_HAVE__COSF) &amp;&amp; ! defined (_GLIBCXX_HAVE_COSF)</span>
<span id="L2025"><span class="lineNum">    2025</span>              : # define _GLIBCXX_HAVE_COSF 1</span>
<span id="L2026"><span class="lineNum">    2026</span>              : # define cosf _cosf</span>
<span id="L2027"><span class="lineNum">    2027</span>              : #endif</span>
<span id="L2028"><span class="lineNum">    2028</span>              : </span>
<span id="L2029"><span class="lineNum">    2029</span>              : #if defined (_GLIBCXX_HAVE__COSHF) &amp;&amp; ! defined (_GLIBCXX_HAVE_COSHF)</span>
<span id="L2030"><span class="lineNum">    2030</span>              : # define _GLIBCXX_HAVE_COSHF 1</span>
<span id="L2031"><span class="lineNum">    2031</span>              : # define coshf _coshf</span>
<span id="L2032"><span class="lineNum">    2032</span>              : #endif</span>
<span id="L2033"><span class="lineNum">    2033</span>              : </span>
<span id="L2034"><span class="lineNum">    2034</span>              : #if defined (_GLIBCXX_HAVE__COSHL) &amp;&amp; ! defined (_GLIBCXX_HAVE_COSHL)</span>
<span id="L2035"><span class="lineNum">    2035</span>              : # define _GLIBCXX_HAVE_COSHL 1</span>
<span id="L2036"><span class="lineNum">    2036</span>              : # define coshl _coshl</span>
<span id="L2037"><span class="lineNum">    2037</span>              : #endif</span>
<span id="L2038"><span class="lineNum">    2038</span>              : </span>
<span id="L2039"><span class="lineNum">    2039</span>              : #if defined (_GLIBCXX_HAVE__COSL) &amp;&amp; ! defined (_GLIBCXX_HAVE_COSL)</span>
<span id="L2040"><span class="lineNum">    2040</span>              : # define _GLIBCXX_HAVE_COSL 1</span>
<span id="L2041"><span class="lineNum">    2041</span>              : # define cosl _cosl</span>
<span id="L2042"><span class="lineNum">    2042</span>              : #endif</span>
<span id="L2043"><span class="lineNum">    2043</span>              : </span>
<span id="L2044"><span class="lineNum">    2044</span>              : #if defined (_GLIBCXX_HAVE__EXPF) &amp;&amp; ! defined (_GLIBCXX_HAVE_EXPF)</span>
<span id="L2045"><span class="lineNum">    2045</span>              : # define _GLIBCXX_HAVE_EXPF 1</span>
<span id="L2046"><span class="lineNum">    2046</span>              : # define expf _expf</span>
<span id="L2047"><span class="lineNum">    2047</span>              : #endif</span>
<span id="L2048"><span class="lineNum">    2048</span>              : </span>
<span id="L2049"><span class="lineNum">    2049</span>              : #if defined (_GLIBCXX_HAVE__EXPL) &amp;&amp; ! defined (_GLIBCXX_HAVE_EXPL)</span>
<span id="L2050"><span class="lineNum">    2050</span>              : # define _GLIBCXX_HAVE_EXPL 1</span>
<span id="L2051"><span class="lineNum">    2051</span>              : # define expl _expl</span>
<span id="L2052"><span class="lineNum">    2052</span>              : #endif</span>
<span id="L2053"><span class="lineNum">    2053</span>              : </span>
<span id="L2054"><span class="lineNum">    2054</span>              : #if defined (_GLIBCXX_HAVE__FABSF) &amp;&amp; ! defined (_GLIBCXX_HAVE_FABSF)</span>
<span id="L2055"><span class="lineNum">    2055</span>              : # define _GLIBCXX_HAVE_FABSF 1</span>
<span id="L2056"><span class="lineNum">    2056</span>              : # define fabsf _fabsf</span>
<span id="L2057"><span class="lineNum">    2057</span>              : #endif</span>
<span id="L2058"><span class="lineNum">    2058</span>              : </span>
<span id="L2059"><span class="lineNum">    2059</span>              : #if defined (_GLIBCXX_HAVE__FABSL) &amp;&amp; ! defined (_GLIBCXX_HAVE_FABSL)</span>
<span id="L2060"><span class="lineNum">    2060</span>              : # define _GLIBCXX_HAVE_FABSL 1</span>
<span id="L2061"><span class="lineNum">    2061</span>              : # define fabsl _fabsl</span>
<span id="L2062"><span class="lineNum">    2062</span>              : #endif</span>
<span id="L2063"><span class="lineNum">    2063</span>              : </span>
<span id="L2064"><span class="lineNum">    2064</span>              : #if defined (_GLIBCXX_HAVE__FINITE) &amp;&amp; ! defined (_GLIBCXX_HAVE_FINITE)</span>
<span id="L2065"><span class="lineNum">    2065</span>              : # define _GLIBCXX_HAVE_FINITE 1</span>
<span id="L2066"><span class="lineNum">    2066</span>              : # define finite _finite</span>
<span id="L2067"><span class="lineNum">    2067</span>              : #endif</span>
<span id="L2068"><span class="lineNum">    2068</span>              : </span>
<span id="L2069"><span class="lineNum">    2069</span>              : #if defined (_GLIBCXX_HAVE__FINITEF) &amp;&amp; ! defined (_GLIBCXX_HAVE_FINITEF)</span>
<span id="L2070"><span class="lineNum">    2070</span>              : # define _GLIBCXX_HAVE_FINITEF 1</span>
<span id="L2071"><span class="lineNum">    2071</span>              : # define finitef _finitef</span>
<span id="L2072"><span class="lineNum">    2072</span>              : #endif</span>
<span id="L2073"><span class="lineNum">    2073</span>              : </span>
<span id="L2074"><span class="lineNum">    2074</span>              : #if defined (_GLIBCXX_HAVE__FINITEL) &amp;&amp; ! defined (_GLIBCXX_HAVE_FINITEL)</span>
<span id="L2075"><span class="lineNum">    2075</span>              : # define _GLIBCXX_HAVE_FINITEL 1</span>
<span id="L2076"><span class="lineNum">    2076</span>              : # define finitel _finitel</span>
<span id="L2077"><span class="lineNum">    2077</span>              : #endif</span>
<span id="L2078"><span class="lineNum">    2078</span>              : </span>
<span id="L2079"><span class="lineNum">    2079</span>              : #if defined (_GLIBCXX_HAVE__FLOORF) &amp;&amp; ! defined (_GLIBCXX_HAVE_FLOORF)</span>
<span id="L2080"><span class="lineNum">    2080</span>              : # define _GLIBCXX_HAVE_FLOORF 1</span>
<span id="L2081"><span class="lineNum">    2081</span>              : # define floorf _floorf</span>
<span id="L2082"><span class="lineNum">    2082</span>              : #endif</span>
<span id="L2083"><span class="lineNum">    2083</span>              : </span>
<span id="L2084"><span class="lineNum">    2084</span>              : #if defined (_GLIBCXX_HAVE__FLOORL) &amp;&amp; ! defined (_GLIBCXX_HAVE_FLOORL)</span>
<span id="L2085"><span class="lineNum">    2085</span>              : # define _GLIBCXX_HAVE_FLOORL 1</span>
<span id="L2086"><span class="lineNum">    2086</span>              : # define floorl _floorl</span>
<span id="L2087"><span class="lineNum">    2087</span>              : #endif</span>
<span id="L2088"><span class="lineNum">    2088</span>              : </span>
<span id="L2089"><span class="lineNum">    2089</span>              : #if defined (_GLIBCXX_HAVE__FMODF) &amp;&amp; ! defined (_GLIBCXX_HAVE_FMODF)</span>
<span id="L2090"><span class="lineNum">    2090</span>              : # define _GLIBCXX_HAVE_FMODF 1</span>
<span id="L2091"><span class="lineNum">    2091</span>              : # define fmodf _fmodf</span>
<span id="L2092"><span class="lineNum">    2092</span>              : #endif</span>
<span id="L2093"><span class="lineNum">    2093</span>              : </span>
<span id="L2094"><span class="lineNum">    2094</span>              : #if defined (_GLIBCXX_HAVE__FMODL) &amp;&amp; ! defined (_GLIBCXX_HAVE_FMODL)</span>
<span id="L2095"><span class="lineNum">    2095</span>              : # define _GLIBCXX_HAVE_FMODL 1</span>
<span id="L2096"><span class="lineNum">    2096</span>              : # define fmodl _fmodl</span>
<span id="L2097"><span class="lineNum">    2097</span>              : #endif</span>
<span id="L2098"><span class="lineNum">    2098</span>              : </span>
<span id="L2099"><span class="lineNum">    2099</span>              : #if defined (_GLIBCXX_HAVE__FPCLASS) &amp;&amp; ! defined (_GLIBCXX_HAVE_FPCLASS)</span>
<span id="L2100"><span class="lineNum">    2100</span>              : # define _GLIBCXX_HAVE_FPCLASS 1</span>
<span id="L2101"><span class="lineNum">    2101</span>              : # define fpclass _fpclass</span>
<span id="L2102"><span class="lineNum">    2102</span>              : #endif</span>
<span id="L2103"><span class="lineNum">    2103</span>              : </span>
<span id="L2104"><span class="lineNum">    2104</span>              : #if defined (_GLIBCXX_HAVE__FREXPF) &amp;&amp; ! defined (_GLIBCXX_HAVE_FREXPF)</span>
<span id="L2105"><span class="lineNum">    2105</span>              : # define _GLIBCXX_HAVE_FREXPF 1</span>
<span id="L2106"><span class="lineNum">    2106</span>              : # define frexpf _frexpf</span>
<span id="L2107"><span class="lineNum">    2107</span>              : #endif</span>
<span id="L2108"><span class="lineNum">    2108</span>              : </span>
<span id="L2109"><span class="lineNum">    2109</span>              : #if defined (_GLIBCXX_HAVE__FREXPL) &amp;&amp; ! defined (_GLIBCXX_HAVE_FREXPL)</span>
<span id="L2110"><span class="lineNum">    2110</span>              : # define _GLIBCXX_HAVE_FREXPL 1</span>
<span id="L2111"><span class="lineNum">    2111</span>              : # define frexpl _frexpl</span>
<span id="L2112"><span class="lineNum">    2112</span>              : #endif</span>
<span id="L2113"><span class="lineNum">    2113</span>              : </span>
<span id="L2114"><span class="lineNum">    2114</span>              : #if defined (_GLIBCXX_HAVE__HYPOT) &amp;&amp; ! defined (_GLIBCXX_HAVE_HYPOT)</span>
<span id="L2115"><span class="lineNum">    2115</span>              : # define _GLIBCXX_HAVE_HYPOT 1</span>
<span id="L2116"><span class="lineNum">    2116</span>              : # define hypot _hypot</span>
<span id="L2117"><span class="lineNum">    2117</span>              : #endif</span>
<span id="L2118"><span class="lineNum">    2118</span>              : </span>
<span id="L2119"><span class="lineNum">    2119</span>              : #if defined (_GLIBCXX_HAVE__HYPOTF) &amp;&amp; ! defined (_GLIBCXX_HAVE_HYPOTF)</span>
<span id="L2120"><span class="lineNum">    2120</span>              : # define _GLIBCXX_HAVE_HYPOTF 1</span>
<span id="L2121"><span class="lineNum">    2121</span>              : # define hypotf _hypotf</span>
<span id="L2122"><span class="lineNum">    2122</span>              : #endif</span>
<span id="L2123"><span class="lineNum">    2123</span>              : </span>
<span id="L2124"><span class="lineNum">    2124</span>              : #if defined (_GLIBCXX_HAVE__HYPOTL) &amp;&amp; ! defined (_GLIBCXX_HAVE_HYPOTL)</span>
<span id="L2125"><span class="lineNum">    2125</span>              : # define _GLIBCXX_HAVE_HYPOTL 1</span>
<span id="L2126"><span class="lineNum">    2126</span>              : # define hypotl _hypotl</span>
<span id="L2127"><span class="lineNum">    2127</span>              : #endif</span>
<span id="L2128"><span class="lineNum">    2128</span>              : </span>
<span id="L2129"><span class="lineNum">    2129</span>              : #if defined (_GLIBCXX_HAVE__ISINF) &amp;&amp; ! defined (_GLIBCXX_HAVE_ISINF)</span>
<span id="L2130"><span class="lineNum">    2130</span>              : # define _GLIBCXX_HAVE_ISINF 1</span>
<span id="L2131"><span class="lineNum">    2131</span>              : # define isinf _isinf</span>
<span id="L2132"><span class="lineNum">    2132</span>              : #endif</span>
<span id="L2133"><span class="lineNum">    2133</span>              : </span>
<span id="L2134"><span class="lineNum">    2134</span>              : #if defined (_GLIBCXX_HAVE__ISINFF) &amp;&amp; ! defined (_GLIBCXX_HAVE_ISINFF)</span>
<span id="L2135"><span class="lineNum">    2135</span>              : # define _GLIBCXX_HAVE_ISINFF 1</span>
<span id="L2136"><span class="lineNum">    2136</span>              : # define isinff _isinff</span>
<span id="L2137"><span class="lineNum">    2137</span>              : #endif</span>
<span id="L2138"><span class="lineNum">    2138</span>              : </span>
<span id="L2139"><span class="lineNum">    2139</span>              : #if defined (_GLIBCXX_HAVE__ISINFL) &amp;&amp; ! defined (_GLIBCXX_HAVE_ISINFL)</span>
<span id="L2140"><span class="lineNum">    2140</span>              : # define _GLIBCXX_HAVE_ISINFL 1</span>
<span id="L2141"><span class="lineNum">    2141</span>              : # define isinfl _isinfl</span>
<span id="L2142"><span class="lineNum">    2142</span>              : #endif</span>
<span id="L2143"><span class="lineNum">    2143</span>              : </span>
<span id="L2144"><span class="lineNum">    2144</span>              : #if defined (_GLIBCXX_HAVE__ISNAN) &amp;&amp; ! defined (_GLIBCXX_HAVE_ISNAN)</span>
<span id="L2145"><span class="lineNum">    2145</span>              : # define _GLIBCXX_HAVE_ISNAN 1</span>
<span id="L2146"><span class="lineNum">    2146</span>              : # define isnan _isnan</span>
<span id="L2147"><span class="lineNum">    2147</span>              : #endif</span>
<span id="L2148"><span class="lineNum">    2148</span>              : </span>
<span id="L2149"><span class="lineNum">    2149</span>              : #if defined (_GLIBCXX_HAVE__ISNANF) &amp;&amp; ! defined (_GLIBCXX_HAVE_ISNANF)</span>
<span id="L2150"><span class="lineNum">    2150</span>              : # define _GLIBCXX_HAVE_ISNANF 1</span>
<span id="L2151"><span class="lineNum">    2151</span>              : # define isnanf _isnanf</span>
<span id="L2152"><span class="lineNum">    2152</span>              : #endif</span>
<span id="L2153"><span class="lineNum">    2153</span>              : </span>
<span id="L2154"><span class="lineNum">    2154</span>              : #if defined (_GLIBCXX_HAVE__ISNANL) &amp;&amp; ! defined (_GLIBCXX_HAVE_ISNANL)</span>
<span id="L2155"><span class="lineNum">    2155</span>              : # define _GLIBCXX_HAVE_ISNANL 1</span>
<span id="L2156"><span class="lineNum">    2156</span>              : # define isnanl _isnanl</span>
<span id="L2157"><span class="lineNum">    2157</span>              : #endif</span>
<span id="L2158"><span class="lineNum">    2158</span>              : </span>
<span id="L2159"><span class="lineNum">    2159</span>              : #if defined (_GLIBCXX_HAVE__LDEXPF) &amp;&amp; ! defined (_GLIBCXX_HAVE_LDEXPF)</span>
<span id="L2160"><span class="lineNum">    2160</span>              : # define _GLIBCXX_HAVE_LDEXPF 1</span>
<span id="L2161"><span class="lineNum">    2161</span>              : # define ldexpf _ldexpf</span>
<span id="L2162"><span class="lineNum">    2162</span>              : #endif</span>
<span id="L2163"><span class="lineNum">    2163</span>              : </span>
<span id="L2164"><span class="lineNum">    2164</span>              : #if defined (_GLIBCXX_HAVE__LDEXPL) &amp;&amp; ! defined (_GLIBCXX_HAVE_LDEXPL)</span>
<span id="L2165"><span class="lineNum">    2165</span>              : # define _GLIBCXX_HAVE_LDEXPL 1</span>
<span id="L2166"><span class="lineNum">    2166</span>              : # define ldexpl _ldexpl</span>
<span id="L2167"><span class="lineNum">    2167</span>              : #endif</span>
<span id="L2168"><span class="lineNum">    2168</span>              : </span>
<span id="L2169"><span class="lineNum">    2169</span>              : #if defined (_GLIBCXX_HAVE__LOG10F) &amp;&amp; ! defined (_GLIBCXX_HAVE_LOG10F)</span>
<span id="L2170"><span class="lineNum">    2170</span>              : # define _GLIBCXX_HAVE_LOG10F 1</span>
<span id="L2171"><span class="lineNum">    2171</span>              : # define log10f _log10f</span>
<span id="L2172"><span class="lineNum">    2172</span>              : #endif</span>
<span id="L2173"><span class="lineNum">    2173</span>              : </span>
<span id="L2174"><span class="lineNum">    2174</span>              : #if defined (_GLIBCXX_HAVE__LOG10L) &amp;&amp; ! defined (_GLIBCXX_HAVE_LOG10L)</span>
<span id="L2175"><span class="lineNum">    2175</span>              : # define _GLIBCXX_HAVE_LOG10L 1</span>
<span id="L2176"><span class="lineNum">    2176</span>              : # define log10l _log10l</span>
<span id="L2177"><span class="lineNum">    2177</span>              : #endif</span>
<span id="L2178"><span class="lineNum">    2178</span>              : </span>
<span id="L2179"><span class="lineNum">    2179</span>              : #if defined (_GLIBCXX_HAVE__LOGF) &amp;&amp; ! defined (_GLIBCXX_HAVE_LOGF)</span>
<span id="L2180"><span class="lineNum">    2180</span>              : # define _GLIBCXX_HAVE_LOGF 1</span>
<span id="L2181"><span class="lineNum">    2181</span>              : # define logf _logf</span>
<span id="L2182"><span class="lineNum">    2182</span>              : #endif</span>
<span id="L2183"><span class="lineNum">    2183</span>              : </span>
<span id="L2184"><span class="lineNum">    2184</span>              : #if defined (_GLIBCXX_HAVE__LOGL) &amp;&amp; ! defined (_GLIBCXX_HAVE_LOGL)</span>
<span id="L2185"><span class="lineNum">    2185</span>              : # define _GLIBCXX_HAVE_LOGL 1</span>
<span id="L2186"><span class="lineNum">    2186</span>              : # define logl _logl</span>
<span id="L2187"><span class="lineNum">    2187</span>              : #endif</span>
<span id="L2188"><span class="lineNum">    2188</span>              : </span>
<span id="L2189"><span class="lineNum">    2189</span>              : #if defined (_GLIBCXX_HAVE__MODF) &amp;&amp; ! defined (_GLIBCXX_HAVE_MODF)</span>
<span id="L2190"><span class="lineNum">    2190</span>              : # define _GLIBCXX_HAVE_MODF 1</span>
<span id="L2191"><span class="lineNum">    2191</span>              : # define modf _modf</span>
<span id="L2192"><span class="lineNum">    2192</span>              : #endif</span>
<span id="L2193"><span class="lineNum">    2193</span>              : </span>
<span id="L2194"><span class="lineNum">    2194</span>              : #if defined (_GLIBCXX_HAVE__MODFF) &amp;&amp; ! defined (_GLIBCXX_HAVE_MODFF)</span>
<span id="L2195"><span class="lineNum">    2195</span>              : # define _GLIBCXX_HAVE_MODFF 1</span>
<span id="L2196"><span class="lineNum">    2196</span>              : # define modff _modff</span>
<span id="L2197"><span class="lineNum">    2197</span>              : #endif</span>
<span id="L2198"><span class="lineNum">    2198</span>              : </span>
<span id="L2199"><span class="lineNum">    2199</span>              : #if defined (_GLIBCXX_HAVE__MODFL) &amp;&amp; ! defined (_GLIBCXX_HAVE_MODFL)</span>
<span id="L2200"><span class="lineNum">    2200</span>              : # define _GLIBCXX_HAVE_MODFL 1</span>
<span id="L2201"><span class="lineNum">    2201</span>              : # define modfl _modfl</span>
<span id="L2202"><span class="lineNum">    2202</span>              : #endif</span>
<span id="L2203"><span class="lineNum">    2203</span>              : </span>
<span id="L2204"><span class="lineNum">    2204</span>              : #if defined (_GLIBCXX_HAVE__POWF) &amp;&amp; ! defined (_GLIBCXX_HAVE_POWF)</span>
<span id="L2205"><span class="lineNum">    2205</span>              : # define _GLIBCXX_HAVE_POWF 1</span>
<span id="L2206"><span class="lineNum">    2206</span>              : # define powf _powf</span>
<span id="L2207"><span class="lineNum">    2207</span>              : #endif</span>
<span id="L2208"><span class="lineNum">    2208</span>              : </span>
<span id="L2209"><span class="lineNum">    2209</span>              : #if defined (_GLIBCXX_HAVE__POWL) &amp;&amp; ! defined (_GLIBCXX_HAVE_POWL)</span>
<span id="L2210"><span class="lineNum">    2210</span>              : # define _GLIBCXX_HAVE_POWL 1</span>
<span id="L2211"><span class="lineNum">    2211</span>              : # define powl _powl</span>
<span id="L2212"><span class="lineNum">    2212</span>              : #endif</span>
<span id="L2213"><span class="lineNum">    2213</span>              : </span>
<span id="L2214"><span class="lineNum">    2214</span>              : #if defined (_GLIBCXX_HAVE__QFPCLASS) &amp;&amp; ! defined (_GLIBCXX_HAVE_QFPCLASS)</span>
<span id="L2215"><span class="lineNum">    2215</span>              : # define _GLIBCXX_HAVE_QFPCLASS 1</span>
<span id="L2216"><span class="lineNum">    2216</span>              : # define qfpclass _qfpclass</span>
<span id="L2217"><span class="lineNum">    2217</span>              : #endif</span>
<span id="L2218"><span class="lineNum">    2218</span>              : </span>
<span id="L2219"><span class="lineNum">    2219</span>              : #if defined (_GLIBCXX_HAVE__SINCOS) &amp;&amp; ! defined (_GLIBCXX_HAVE_SINCOS)</span>
<span id="L2220"><span class="lineNum">    2220</span>              : # define _GLIBCXX_HAVE_SINCOS 1</span>
<span id="L2221"><span class="lineNum">    2221</span>              : # define sincos _sincos</span>
<span id="L2222"><span class="lineNum">    2222</span>              : #endif</span>
<span id="L2223"><span class="lineNum">    2223</span>              : </span>
<span id="L2224"><span class="lineNum">    2224</span>              : #if defined (_GLIBCXX_HAVE__SINCOSF) &amp;&amp; ! defined (_GLIBCXX_HAVE_SINCOSF)</span>
<span id="L2225"><span class="lineNum">    2225</span>              : # define _GLIBCXX_HAVE_SINCOSF 1</span>
<span id="L2226"><span class="lineNum">    2226</span>              : # define sincosf _sincosf</span>
<span id="L2227"><span class="lineNum">    2227</span>              : #endif</span>
<span id="L2228"><span class="lineNum">    2228</span>              : </span>
<span id="L2229"><span class="lineNum">    2229</span>              : #if defined (_GLIBCXX_HAVE__SINCOSL) &amp;&amp; ! defined (_GLIBCXX_HAVE_SINCOSL)</span>
<span id="L2230"><span class="lineNum">    2230</span>              : # define _GLIBCXX_HAVE_SINCOSL 1</span>
<span id="L2231"><span class="lineNum">    2231</span>              : # define sincosl _sincosl</span>
<span id="L2232"><span class="lineNum">    2232</span>              : #endif</span>
<span id="L2233"><span class="lineNum">    2233</span>              : </span>
<span id="L2234"><span class="lineNum">    2234</span>              : #if defined (_GLIBCXX_HAVE__SINF) &amp;&amp; ! defined (_GLIBCXX_HAVE_SINF)</span>
<span id="L2235"><span class="lineNum">    2235</span>              : # define _GLIBCXX_HAVE_SINF 1</span>
<span id="L2236"><span class="lineNum">    2236</span>              : # define sinf _sinf</span>
<span id="L2237"><span class="lineNum">    2237</span>              : #endif</span>
<span id="L2238"><span class="lineNum">    2238</span>              : </span>
<span id="L2239"><span class="lineNum">    2239</span>              : #if defined (_GLIBCXX_HAVE__SINHF) &amp;&amp; ! defined (_GLIBCXX_HAVE_SINHF)</span>
<span id="L2240"><span class="lineNum">    2240</span>              : # define _GLIBCXX_HAVE_SINHF 1</span>
<span id="L2241"><span class="lineNum">    2241</span>              : # define sinhf _sinhf</span>
<span id="L2242"><span class="lineNum">    2242</span>              : #endif</span>
<span id="L2243"><span class="lineNum">    2243</span>              : </span>
<span id="L2244"><span class="lineNum">    2244</span>              : #if defined (_GLIBCXX_HAVE__SINHL) &amp;&amp; ! defined (_GLIBCXX_HAVE_SINHL)</span>
<span id="L2245"><span class="lineNum">    2245</span>              : # define _GLIBCXX_HAVE_SINHL 1</span>
<span id="L2246"><span class="lineNum">    2246</span>              : # define sinhl _sinhl</span>
<span id="L2247"><span class="lineNum">    2247</span>              : #endif</span>
<span id="L2248"><span class="lineNum">    2248</span>              : </span>
<span id="L2249"><span class="lineNum">    2249</span>              : #if defined (_GLIBCXX_HAVE__SINL) &amp;&amp; ! defined (_GLIBCXX_HAVE_SINL)</span>
<span id="L2250"><span class="lineNum">    2250</span>              : # define _GLIBCXX_HAVE_SINL 1</span>
<span id="L2251"><span class="lineNum">    2251</span>              : # define sinl _sinl</span>
<span id="L2252"><span class="lineNum">    2252</span>              : #endif</span>
<span id="L2253"><span class="lineNum">    2253</span>              : </span>
<span id="L2254"><span class="lineNum">    2254</span>              : #if defined (_GLIBCXX_HAVE__SQRTF) &amp;&amp; ! defined (_GLIBCXX_HAVE_SQRTF)</span>
<span id="L2255"><span class="lineNum">    2255</span>              : # define _GLIBCXX_HAVE_SQRTF 1</span>
<span id="L2256"><span class="lineNum">    2256</span>              : # define sqrtf _sqrtf</span>
<span id="L2257"><span class="lineNum">    2257</span>              : #endif</span>
<span id="L2258"><span class="lineNum">    2258</span>              : </span>
<span id="L2259"><span class="lineNum">    2259</span>              : #if defined (_GLIBCXX_HAVE__SQRTL) &amp;&amp; ! defined (_GLIBCXX_HAVE_SQRTL)</span>
<span id="L2260"><span class="lineNum">    2260</span>              : # define _GLIBCXX_HAVE_SQRTL 1</span>
<span id="L2261"><span class="lineNum">    2261</span>              : # define sqrtl _sqrtl</span>
<span id="L2262"><span class="lineNum">    2262</span>              : #endif</span>
<span id="L2263"><span class="lineNum">    2263</span>              : </span>
<span id="L2264"><span class="lineNum">    2264</span>              : #if defined (_GLIBCXX_HAVE__STRTOF) &amp;&amp; ! defined (_GLIBCXX_HAVE_STRTOF)</span>
<span id="L2265"><span class="lineNum">    2265</span>              : # define _GLIBCXX_HAVE_STRTOF 1</span>
<span id="L2266"><span class="lineNum">    2266</span>              : # define strtof _strtof</span>
<span id="L2267"><span class="lineNum">    2267</span>              : #endif</span>
<span id="L2268"><span class="lineNum">    2268</span>              : </span>
<span id="L2269"><span class="lineNum">    2269</span>              : #if defined (_GLIBCXX_HAVE__STRTOLD) &amp;&amp; ! defined (_GLIBCXX_HAVE_STRTOLD)</span>
<span id="L2270"><span class="lineNum">    2270</span>              : # define _GLIBCXX_HAVE_STRTOLD 1</span>
<span id="L2271"><span class="lineNum">    2271</span>              : # define strtold _strtold</span>
<span id="L2272"><span class="lineNum">    2272</span>              : #endif</span>
<span id="L2273"><span class="lineNum">    2273</span>              : </span>
<span id="L2274"><span class="lineNum">    2274</span>              : #if defined (_GLIBCXX_HAVE__TANF) &amp;&amp; ! defined (_GLIBCXX_HAVE_TANF)</span>
<span id="L2275"><span class="lineNum">    2275</span>              : # define _GLIBCXX_HAVE_TANF 1</span>
<span id="L2276"><span class="lineNum">    2276</span>              : # define tanf _tanf</span>
<span id="L2277"><span class="lineNum">    2277</span>              : #endif</span>
<span id="L2278"><span class="lineNum">    2278</span>              : </span>
<span id="L2279"><span class="lineNum">    2279</span>              : #if defined (_GLIBCXX_HAVE__TANHF) &amp;&amp; ! defined (_GLIBCXX_HAVE_TANHF)</span>
<span id="L2280"><span class="lineNum">    2280</span>              : # define _GLIBCXX_HAVE_TANHF 1</span>
<span id="L2281"><span class="lineNum">    2281</span>              : # define tanhf _tanhf</span>
<span id="L2282"><span class="lineNum">    2282</span>              : #endif</span>
<span id="L2283"><span class="lineNum">    2283</span>              : </span>
<span id="L2284"><span class="lineNum">    2284</span>              : #if defined (_GLIBCXX_HAVE__TANHL) &amp;&amp; ! defined (_GLIBCXX_HAVE_TANHL)</span>
<span id="L2285"><span class="lineNum">    2285</span>              : # define _GLIBCXX_HAVE_TANHL 1</span>
<span id="L2286"><span class="lineNum">    2286</span>              : # define tanhl _tanhl</span>
<span id="L2287"><span class="lineNum">    2287</span>              : #endif</span>
<span id="L2288"><span class="lineNum">    2288</span>              : </span>
<span id="L2289"><span class="lineNum">    2289</span>              : #if defined (_GLIBCXX_HAVE__TANL) &amp;&amp; ! defined (_GLIBCXX_HAVE_TANL)</span>
<span id="L2290"><span class="lineNum">    2290</span>              : # define _GLIBCXX_HAVE_TANL 1</span>
<span id="L2291"><span class="lineNum">    2291</span>              : # define tanl _tanl</span>
<span id="L2292"><span class="lineNum">    2292</span>              : #endif</span>
<span id="L2293"><span class="lineNum">    2293</span>              : </span>
<span id="L2294"><span class="lineNum">    2294</span>              : #endif // _GLIBCXX_CXX_CONFIG_H</span>
        </pre>
              </td>
            </tr>
          </table>
          <br>

          <table width="100%" border=0 cellspacing=0 cellpadding=0>
            <tr><td class="ruler"><img src="../../../../../../glass.png" width=3 height=3 alt=""></td></tr>
            <tr><td class="versionInfo">Generated by: <a href="https://github.com//linux-test-project/lcov" target="_parent">LCOV version 2.0-1</a></td></tr>
          </table>
          <br>

</body>
</html>
